diff --git a/test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/BUILD.gn index 25f6b34d81c1927d31763313f2c85b67c23ff139..6ed9dc3453ddb61bcec163daa14615fc8705713d 100644 --- a/test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/BUILD.gn @@ -31,7 +31,7 @@ ohos_fuzztest("AccessfTokenidGrpTestFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "accessftokenidgrptest_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/accessftokenidgrptest_fuzzer.cpp b/test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/accessftokenidgrptest_fuzzer.cpp index c535b276f673a73131c438ea23a555b3ad9c7101..2dc2296eb4392e25d05a749f8e694dfec8c6c226 100644 --- a/test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/accessftokenidgrptest_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/accessftokenidgrptest_fuzzer/accessftokenidgrptest_fuzzer.cpp @@ -14,7 +14,10 @@ */ #include -#include "accessftokenidcommon.h" +#include +#include +#include "__config" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; diff --git a/test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/BUILD.gn index d902d27f417973e42fb0de63fcbba0f6935de5db..6e4cbfc4975bdb1e1ed9758c0bf325deb25717ac 100644 --- a/test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/BUILD.gn @@ -31,7 +31,7 @@ ohos_fuzztest("AccessfTokenidGrpTestOtherFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "accessftokenidgrptestother_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/accessftokenidgrptestother_fuzzer.cpp b/test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/accessftokenidgrptestother_fuzzer.cpp index 399d77f49cbe2bf363a29dcd0d263dca7a206537..6a58dfe59ee6f0974c8c81e507a51d62d164f1d2 100644 --- a/test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/accessftokenidgrptestother_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/accessftokenidgrptestother_fuzzer/accessftokenidgrptestother_fuzzer.cpp @@ -14,7 +14,10 @@ */ #include -#include "accessftokenidcommon.h" +#include +#include +#include "__config" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; diff --git a/test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/BUILD.gn index 3bdbd2bbb40092340d484da3c7d6a22b3fc20c11..b842dac84218b3db6385b679462937cf53985154 100644 --- a/test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/BUILD.gn @@ -31,7 +31,7 @@ ohos_fuzztest("AccessfTokenidThreadTestFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "accessftokenidthreadtest_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/accessftokenidthreadtest_fuzzer.cpp b/test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/accessftokenidthreadtest_fuzzer.cpp index 42129808f82758415c5ffa9c8ea2598935b30ae3..ad8101a3dd9bd702c93a96ce3a0f1a17a32864fb 100644 --- a/test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/accessftokenidthreadtest_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/accessftokenidthreadtest_fuzzer/accessftokenidthreadtest_fuzzer.cpp @@ -14,7 +14,10 @@ */ #include -#include "accessftokenidcommon.h" +#include +#include +#include "__config" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; diff --git a/test/fuzztest/accesstokenid/accesstokenidgrptest_fuzzer/accesstokenidgrptest_fuzzer.cpp b/test/fuzztest/accesstokenid/accesstokenidgrptest_fuzzer/accesstokenidgrptest_fuzzer.cpp index af5b63685345d7d0c4710b08fef1619c9126aa1c..872a7bd96471bc58634eb01dab46e9aaa587076d 100644 --- a/test/fuzztest/accesstokenid/accesstokenidgrptest_fuzzer/accesstokenidgrptest_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/accesstokenidgrptest_fuzzer/accesstokenidgrptest_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "accesstokenidcommon.h" using namespace std; diff --git a/test/fuzztest/accesstokenid/accesstokenidgrptestother_fuzzer/accesstokenidgrptestother_fuzzer.cpp b/test/fuzztest/accesstokenid/accesstokenidgrptestother_fuzzer/accesstokenidgrptestother_fuzzer.cpp index a4e57da17d3d51a68e837588583f6a8787f7a158..d0437f96c75b852fce2ecc2261f0e58cbf3726ca 100644 --- a/test/fuzztest/accesstokenid/accesstokenidgrptestother_fuzzer/accesstokenidgrptestother_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/accesstokenidgrptestother_fuzzer/accesstokenidgrptestother_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "accesstokenidcommon.h" using namespace std; diff --git a/test/fuzztest/accesstokenid/accesstokenidthreadtest_fuzzer/accesstokenidthreadtest_fuzzer.cpp b/test/fuzztest/accesstokenid/accesstokenidthreadtest_fuzzer/accesstokenidthreadtest_fuzzer.cpp index 5215747069b19cdb0e76324df45db7f2572a293e..0aadbf70dbd56398db9776ceb6a85eef70b1c672 100644 --- a/test/fuzztest/accesstokenid/accesstokenidthreadtest_fuzzer/accesstokenidthreadtest_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/accesstokenidthreadtest_fuzzer/accesstokenidthreadtest_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "accesstokenidcommon.h" using namespace std; diff --git a/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/BUILD.gn index dd833e2068a3286420d1f26f7a8c8193b5325c0f..da9537e47753be4285409e91fe66817ad9a27c24 100644 --- a/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/BUILD.gn @@ -30,7 +30,7 @@ ohos_fuzztest("GetfTokenidCmdCorrectFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "getftokenidcmdcorrect_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/getftokenidcmdcorrect_fuzzer.cpp b/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/getftokenidcmdcorrect_fuzzer.cpp index 1173bb9352a3a98c6b0d14b8ae7b24f1bcc6d030..f59e1c709e8123a9560d983d9c4502b7db7b759d 100644 --- a/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/getftokenidcmdcorrect_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/getftokenidcmdcorrect_fuzzer.cpp @@ -14,20 +14,17 @@ */ #include -#include "accessftokenidcommon.h" +#include +#include +#include "__config" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; namespace OHOS { bool GetfTokenidCmdCorrectFuzzTest(const uint8_t *data, size_t size) { - bool ret = false; - if ((data == nullptr) || (size < sizeof(unsigned long long))) { - return ret; - } else { - unsigned long long tokenId = *(reinterpret_cast(data)); - ret = GetfTokenid(&tokenId); - } + bool ret = GetfTokenidCmdFuzzTest(data, size); return ret; } } diff --git a/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/BUILD.gn index 66b1aab8178c3de7ab0ef03e7bc287ac00a9f719..1464b6f84ab676d4e83c15491337076bbf80152e 100644 --- a/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/BUILD.gn @@ -30,7 +30,7 @@ ohos_fuzztest("GetfTokenidCmdErrorFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "getftokenidcmderror_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/getftokenidcmderror_fuzzer.cpp b/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/getftokenidcmderror_fuzzer.cpp index 0ffb6a996379b9cdb5d2c4dadd386f5e6ac5449d..e5c2ef7d66e08fd66c9e8fcc7652ded36e31a378 100644 --- a/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/getftokenidcmderror_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/getftokenidcmderror_fuzzer.cpp @@ -14,21 +14,18 @@ */ #include +#include +#include +#include "__config" #define CMDERROR -#include "accessftokenidcommon.h" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; namespace OHOS { bool GetfTokenidCmdCorrectFuzzTest(const uint8_t *data, size_t size) { - bool ret = false; - if ((data == nullptr) || (size < sizeof(unsigned long long))) { - return ret; - } else { - unsigned long long tokenId = *(reinterpret_cast(data)); - ret = GetfTokenid(&tokenId); - } + bool ret = GetfTokenidCmdFuzzTest(data, size); return ret; } } diff --git a/test/fuzztest/accesstokenid/getftokenidnullptr_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/getftokenidnullptr_fuzzer/BUILD.gn index a7aa7278a55657d3651f13da66e2c3ac16bae9a8..8b092e614c5a28979bc4d47622193ae351d687d5 100644 --- a/test/fuzztest/accesstokenid/getftokenidnullptr_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/getftokenidnullptr_fuzzer/BUILD.gn @@ -30,7 +30,7 @@ ohos_fuzztest("GetfTokenidNullptrFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "getftokenidnullptr_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/getftokenidnullptr_fuzzer/getftokenidnullptr_fuzzer.cpp b/test/fuzztest/accesstokenid/getftokenidnullptr_fuzzer/getftokenidnullptr_fuzzer.cpp index c098598c96f64f3811bc60a111979a9425b9ac6b..0882bb7068b5ae6c0b614e0bd1f2f481255952c7 100644 --- a/test/fuzztest/accesstokenid/getftokenidnullptr_fuzzer/getftokenidnullptr_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/getftokenidnullptr_fuzzer/getftokenidnullptr_fuzzer.cpp @@ -16,7 +16,10 @@ */ #include -#include "accessftokenidcommon.h" +#include +#include +#include "__config" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; diff --git a/test/fuzztest/accesstokenid/gettokenidcmdcorrect_fuzzer/gettokenidcmdcorrect_fuzzer.cpp b/test/fuzztest/accesstokenid/gettokenidcmdcorrect_fuzzer/gettokenidcmdcorrect_fuzzer.cpp index 40762c219ab01753b52fd948f3be228ac15151a3..310c2a9beb9c956e02d9752d7e3ce22f284105e9 100644 --- a/test/fuzztest/accesstokenid/gettokenidcmdcorrect_fuzzer/gettokenidcmdcorrect_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/gettokenidcmdcorrect_fuzzer/gettokenidcmdcorrect_fuzzer.cpp @@ -16,6 +16,9 @@ */ #include +#include +#include +#include "__config" #include "accesstokenidcommon.h" using namespace std; @@ -23,13 +26,7 @@ using namespace OHOS::Kernel::AccessToken; namespace OHOS { bool GetTokenidCmdCorrectFuzzTest(const uint8_t *data, size_t size) { - bool ret = false; - if ((data == nullptr) || (size < sizeof(unsigned long long))) { - return ret; - } else { - unsigned long long tokenId = *(reinterpret_cast(data)); - ret = GetTokenid(&tokenId); - } + bool ret = GetTokenidCmdFuzzTest(data, size); return ret; } } diff --git a/test/fuzztest/accesstokenid/gettokenidcmdcorrect_fuzzer/gettokenidcmdcorrect_fuzzer.h b/test/fuzztest/accesstokenid/gettokenidcmdcorrect_fuzzer/gettokenidcmdcorrect_fuzzer.h deleted file mode 100644 index 2ac8751939bb9810ce3ba007307b1ea178bd29b4..0000000000000000000000000000000000000000 --- a/test/fuzztest/accesstokenid/gettokenidcmdcorrect_fuzzer/gettokenidcmdcorrect_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef TEST_FUZZTEST_GETTOKENIDCMDCORRECT_FUZZER_H -#define TEST_FUZZTEST_GETTOKENIDCMDCORRECT_FUZZER_H - -#define FUZZ_PROJECT_NAME "gettokenidcmdcorrect_fuzzer" - -#endif // TEST_FUZZTEST_GETTOKENIDCMDCORRECT_FUZZER_H diff --git a/test/fuzztest/accesstokenid/gettokenidcmderror_fuzzer/gettokenidcmderror_fuzzer.cpp b/test/fuzztest/accesstokenid/gettokenidcmderror_fuzzer/gettokenidcmderror_fuzzer.cpp index 46d305e8b425f7fea67f3e039097e1eee3b68ace..28255d69ada830e4a36eaf4ee519a11091e8310d 100644 --- a/test/fuzztest/accesstokenid/gettokenidcmderror_fuzzer/gettokenidcmderror_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/gettokenidcmderror_fuzzer/gettokenidcmderror_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #define CMDERROR #include "accesstokenidcommon.h" @@ -22,13 +25,7 @@ using namespace OHOS::Kernel::AccessToken; namespace OHOS { bool GetTokenidCmdErrorFuzzTest(const uint8_t *data, size_t size) { - bool ret = false; - if ((data == nullptr) || (size < sizeof(unsigned long long))) { - return ret; - } else { - unsigned long long tokenId = *(reinterpret_cast(data)); - ret = GetTokenid(&tokenId); - } + bool ret = GetTokenidCmdFuzzTest(data, size); return ret; } } diff --git a/test/fuzztest/accesstokenid/gettokenidnullptr_fuzzer/gettokenidnullptr_fuzzer.cpp b/test/fuzztest/accesstokenid/gettokenidnullptr_fuzzer/gettokenidnullptr_fuzzer.cpp index 5be434efe3e662e364592d7f6f59f41af052354d..a6a862fa5c9e41ed3cfb6ed946a53a28f1722608 100644 --- a/test/fuzztest/accesstokenid/gettokenidnullptr_fuzzer/gettokenidnullptr_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/gettokenidnullptr_fuzzer/gettokenidnullptr_fuzzer.cpp @@ -16,6 +16,9 @@ */ #include +#include +#include +#include "__config" #include "accesstokenidcommon.h" using namespace std; diff --git a/test/fuzztest/accesstokenid/include/accessftokenidcommon.h b/test/fuzztest/accesstokenid/include/accessftokenidcommon.h deleted file mode 100644 index e0c3903814f6e5c8f8ac84ac8bca07d9c2629a5d..0000000000000000000000000000000000000000 --- a/test/fuzztest/accesstokenid/include/accessftokenidcommon.h +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ACCESSFTOKENIDCOMMON_H -#define ACCESSFTOKENIDCOMMON_H - -#define FUZZ_PROJECT_NAME "accessftokenidcommon" - -namespace OHOS { -namespace Kernel { -namespace AccessToken { -#define ACCESS_TOKEN_ID_IOCTL_BASE 'A' - -#ifdef CMDERROR -constexpr unsigned int GET_FTOKEN_ID = 0; -constexpr unsigned int SET_FTOKEN_ID = 0; -#else -constexpr unsigned int GET_FTOKEN_ID = 3; -constexpr unsigned int SET_FTOKEN_ID = 4; -#endif - -#define ACCESS_TOKENID_GET_FTOKENID \ - _IOR(ACCESS_TOKEN_ID_IOCTL_BASE, GET_FTOKEN_ID, unsigned long long) -#define ACCESS_TOKENID_SET_FTOKENID \ - _IOW(ACCESS_TOKEN_ID_IOCTL_BASE, SET_FTOKEN_ID, unsigned long long) - -#define LIST_NUM_1 1 -#define LIST_NUM_2 2 -#define TEST_VALUE 123 -#define CHILDREN_NUM 3 -#define WAIT_FOR_SHELL_OP_TIME 1 -#define FATHER_WAIT_TIME (WAIT_FOR_SHELL_OP_TIME * (CHILDREN_NUM + 1)) - -#define ACCESS_TOKEN_UID 3020 -#define ACCESS_TOKEN_GRPID 3020 - -#define ACCESS_TOKEN_OTHER_UID 1234 -#define ACCESS_TOKEN_OTHER_GRPID 1234 - -#define INVAL_TOKEN 0xffffffffffffffff - -int GetfTokenid(unsigned long long *ftoken); -int SetfTokenid(unsigned long long *ftoken); - -void SetUidAndGrp(); -void SetUidAndGrpOther(); -void GetCurfToken(unsigned long long *ftoken); -void SetRandfTokenAndCheck(unsigned long long *data_ftoken); -void fTokenTest(unsigned long long *data_ftoken); -void ThreadTest(unsigned long long *data_ftoken); -int AccessfTokenidThreadTest(uint8_t *data_ftoken); -int AccessfTokenidGrpTest(uint8_t *data_ftoken); -int AccessfTokenidGrpTestOther(uint8_t *data_ftoken); -} // namespace AccessToken -} // namespace Kernel -} // namespace OHOS - -#endif // ACCESSTOKENIDCOMMON_H diff --git a/test/fuzztest/accesstokenid/include/accesstokenidcommon.h b/test/fuzztest/accesstokenid/include/accesstokenidcommon.h index febe47573e273447a4db1992012e962dc20b96d3..ba3bde74237fe60fac7dea896fc62c09e088d5a9 100644 --- a/test/fuzztest/accesstokenid/include/accesstokenidcommon.h +++ b/test/fuzztest/accesstokenid/include/accesstokenidcommon.h @@ -15,6 +15,8 @@ #ifndef ACCESSTOKENIDCOMMON_H #define ACCESSTOKENIDCOMMON_H +#include +#include #define FUZZ_PROJECT_NAME "accesstokenidcommon" @@ -24,17 +26,25 @@ namespace AccessToken { #define ACCESS_TOKEN_ID_IOCTL_BASE 'A' #ifdef CMDERROR -constexpr unsigned int GET_TOKEN_ID = 0; -constexpr unsigned int SET_TOKEN_ID = 0; +constexpr unsigned int get_token_id = 0; +constexpr unsigned int set_token_id = 0; +constexpr unsigned int get_ftoken_id = 0; +constexpr unsigned int set_ftoken_id = 0; #else -constexpr unsigned int GET_TOKEN_ID = 1; -constexpr unsigned int SET_TOKEN_ID = 2; +constexpr unsigned int get_token_id = 1; +constexpr unsigned int set_token_id = 2; +constexpr unsigned int get_ftoken_id = 3; +constexpr unsigned int set_ftoken_id = 4; #endif #define ACCESS_TOKENID_GET_TOKENID \ - _IOR(ACCESS_TOKEN_ID_IOCTL_BASE, GET_TOKEN_ID, unsigned long long) + _IOR(ACCESS_TOKEN_ID_IOCTL_BASE, get_token_id, unsigned long long) #define ACCESS_TOKENID_SET_TOKENID \ - _IOW(ACCESS_TOKEN_ID_IOCTL_BASE, SET_TOKEN_ID, unsigned long long) + _IOW(ACCESS_TOKEN_ID_IOCTL_BASE, set_token_id, unsigned long long) +#define ACCESS_TOKENID_GET_FTOKENID \ + _IOR(ACCESS_TOKEN_ID_IOCTL_BASE, get_ftoken_id, unsigned long long) +#define ACCESS_TOKENID_SET_FTOKENID \ + _IOW(ACCESS_TOKEN_ID_IOCTL_BASE, set_ftoken_id, unsigned long long) #define LIST_NUM_1 1 #define LIST_NUM_2 2 @@ -53,6 +63,8 @@ constexpr unsigned int SET_TOKEN_ID = 2; int GetTokenid(unsigned long long *token); int SetTokenid(unsigned long long *token); +int GetfTokenid(unsigned long long *ftoken); +int SetfTokenid(unsigned long long *ftoken); void SetUidAndGrp(); void SetUidAndGrpOther(); @@ -63,6 +75,18 @@ void ThreadTest(unsigned long long *data_token); int AccessTokenidThreadTest(uint8_t *data_token); int AccessTokenidGrpTest(uint8_t *data_token); int AccessTokenidGrpTestOther(uint8_t *data_token); + +void GetCurfToken(unsigned long long *ftoken); +void SetRandfTokenAndCheck(unsigned long long *data_ftoken); +void fTokenTest(unsigned long long *data_ftoken); +void ThreadTest(unsigned long long *data_ftoken); +int AccessfTokenidThreadTest(uint8_t *data_ftoken); +int AccessfTokenidGrpTest(uint8_t *data_ftoken); +int AccessfTokenidGrpTestOther(uint8_t *data_ftoken); +bool SetfTokenidCmdFuzzTest(const uint8_t *data, size_t size); +bool GetfTokenidCmdFuzzTest(const uint8_t *data, size_t size); +bool SetTokenidCmdFuzzTest(const uint8_t *data, size_t size); +bool GetTokenidCmdFuzzTest(const uint8_t *data, size_t size); } // namespace AccessToken } // namespace Kernel } // namespace OHOS diff --git a/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/BUILD.gn index bdabf6fa9cc37a6801b48d146972d4d2d402a90e..bf9b79cd11837a14ea3e90ac1150105c4754c438 100644 --- a/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/BUILD.gn @@ -30,7 +30,7 @@ ohos_fuzztest("SetfTokenidCmdCorrectFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "setftokenidcmdcorrect_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/setftokenidcmdcorrect_fuzzer.cpp b/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/setftokenidcmdcorrect_fuzzer.cpp index 000316cb94c492fd14bd3f28d4ad6a4eec791df3..35b1d10764075cfc95367769dbd0d17b4941131e 100644 --- a/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/setftokenidcmdcorrect_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/setftokenidcmdcorrect_fuzzer.cpp @@ -14,20 +14,17 @@ */ #include -#include "accessftokenidcommon.h" +#include +#include +#include "__config" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; namespace OHOS { bool SetfTokenidCmdCorrectFuzzTest(const uint8_t *data, size_t size) { - bool ret = false; - if ((data == nullptr) || (size < sizeof(unsigned long long))) { - return ret; - } else { - unsigned long long tokenId = *(reinterpret_cast(data)); - ret = SetfTokenid(&tokenId); - } + bool ret = SetfTokenidCmdFuzzTest(data, size); return ret; } } diff --git a/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/setftokenidcmdcorrect_fuzzer.h b/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/setftokenidcmdcorrect_fuzzer.h deleted file mode 100644 index 0b440c269cba3ffe7fb0d3670ded743e405aec24..0000000000000000000000000000000000000000 --- a/test/fuzztest/accesstokenid/setftokenidcmdcorrect_fuzzer/setftokenidcmdcorrect_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef TEST_FUZZTEST_SETFTOKENIDCMDCORRECT_FUZZER_H -#define TEST_FUZZTEST_SETFTOKENIDCMDCORRECT_FUZZER_H - -#define FUZZ_PROJECT_NAME "setftokenidcmdcorrect_fuzzer" - -#endif // TEST_FUZZTEST_SETFTOKENIDCMDCORRECT_FUZZER_H diff --git a/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/BUILD.gn index 00fb0ffc6e165a7435d002b6b42a249fbe6b2e60..3a642c1071213f6fff7d968c3f7ac0ef2ba4c533 100644 --- a/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/BUILD.gn @@ -30,7 +30,7 @@ ohos_fuzztest("SetfTokenidCmdErrorFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "setftokenidcmderror_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/setftokenidcmderror_fuzzer.cpp b/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/setftokenidcmderror_fuzzer.cpp index 9a2f08595bfa7f7e3631adc2caf37411d3e41e60..7edb5fda1adb4e9110a998da3f230df053b74117 100644 --- a/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/setftokenidcmderror_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/setftokenidcmderror_fuzzer.cpp @@ -14,21 +14,18 @@ */ #include +#include +#include +#include "__config" #define CMDERROR -#include "accessftokenidcommon.h" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; namespace OHOS { bool SetfTokenidCmdErrorFuzzTest(const uint8_t *data, size_t size) { - bool ret = false; - if ((data == nullptr) || (size < sizeof(unsigned long long))) { - return ret; - } else { - unsigned long long tokenId = *(reinterpret_cast(data)); - ret = SetfTokenid(&tokenId); - } + bool ret = SetfTokenidCmdFuzzTest(data, size); return ret; } } diff --git a/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/setftokenidcmderror_fuzzer.h b/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/setftokenidcmderror_fuzzer.h deleted file mode 100644 index 3ab67c53750f506e4f4dafd58cc3fca9d9f7a005..0000000000000000000000000000000000000000 --- a/test/fuzztest/accesstokenid/setftokenidcmderror_fuzzer/setftokenidcmderror_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef TEST_FUZZTEST_SETFTOKENIDCMDERROR_FUZZER_H -#define TEST_FUZZTEST_SETFTOKENIDCMDERROR_FUZZER_H - -#define FUZZ_PROJECT_NAME "setftokenidcmderror_fuzzer" - -#endif // TEST_FUZZTEST_SETFTOKENIDCMDERROR_FUZZER_H diff --git a/test/fuzztest/accesstokenid/setftokenidnullptr_fuzzer/BUILD.gn b/test/fuzztest/accesstokenid/setftokenidnullptr_fuzzer/BUILD.gn index 0847e822561b035a429bf7825a397478c8662c93..6d4ebbcd4cd5546aa3421bc27cb7846579f55461 100644 --- a/test/fuzztest/accesstokenid/setftokenidnullptr_fuzzer/BUILD.gn +++ b/test/fuzztest/accesstokenid/setftokenidnullptr_fuzzer/BUILD.gn @@ -30,7 +30,7 @@ ohos_fuzztest("SetfTokenidNullptrFuzzTest") { ] sources = [ - "../src/accessftokenidcommon.cpp", + "../src/accesstokenidcommon.cpp", "setftokenidnullptr_fuzzer.cpp", ] } diff --git a/test/fuzztest/accesstokenid/setftokenidnullptr_fuzzer/setftokenidnullptr_fuzzer.cpp b/test/fuzztest/accesstokenid/setftokenidnullptr_fuzzer/setftokenidnullptr_fuzzer.cpp index f79706f091622994daa87c5cb3c927df2ae88a9c..767131572df3229185a7802ea39881ebeb457c7e 100644 --- a/test/fuzztest/accesstokenid/setftokenidnullptr_fuzzer/setftokenidnullptr_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/setftokenidnullptr_fuzzer/setftokenidnullptr_fuzzer.cpp @@ -16,7 +16,10 @@ */ #include -#include "accessftokenidcommon.h" +#include +#include +#include "__config" +#include "accesstokenidcommon.h" using namespace std; using namespace OHOS::Kernel::AccessToken; diff --git a/test/fuzztest/accesstokenid/settokenidcmdcorrect_fuzzer/settokenidcmdcorrect_fuzzer.cpp b/test/fuzztest/accesstokenid/settokenidcmdcorrect_fuzzer/settokenidcmdcorrect_fuzzer.cpp index 7183f678a1f862899d99c7c5ac411217b6267fc1..212190c0d16dc191fb0f5436e57695b64786b029 100644 --- a/test/fuzztest/accesstokenid/settokenidcmdcorrect_fuzzer/settokenidcmdcorrect_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/settokenidcmdcorrect_fuzzer/settokenidcmdcorrect_fuzzer.cpp @@ -16,6 +16,9 @@ */ #include +#include +#include +#include "__config" #include "accesstokenidcommon.h" using namespace std; @@ -23,13 +26,7 @@ using namespace OHOS::Kernel::AccessToken; namespace OHOS { bool SetTokenidCmdCorrectFuzzTest(const uint8_t *data, size_t size) { - bool ret = false; - if ((data == nullptr) || (size < sizeof(unsigned long long))) { - return ret; - } else { - unsigned long long tokenId = *(reinterpret_cast(data)); - ret = SetTokenid(&tokenId); - } + bool ret = SetTokenidCmdFuzzTest(data, size); return ret; } } diff --git a/test/fuzztest/accesstokenid/settokenidcmdcorrect_fuzzer/settokenidcmdcorrect_fuzzer.h b/test/fuzztest/accesstokenid/settokenidcmdcorrect_fuzzer/settokenidcmdcorrect_fuzzer.h deleted file mode 100644 index 4cc82cad5a4a8084a7a1453e9e4c0d29cf8d29ab..0000000000000000000000000000000000000000 --- a/test/fuzztest/accesstokenid/settokenidcmdcorrect_fuzzer/settokenidcmdcorrect_fuzzer.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef TEST_FUZZTEST_SETTOKENIDCMDCORRECT_FUZZER_H -#define TEST_FUZZTEST_SETTOKENIDCMDCORRECT_FUZZER_H - -#define FUZZ_PROJECT_NAME "settokenidcmdcorrect_fuzzer" - -#endif // TEST_FUZZTEST_SETTOKENIDCMDCORRECT_FUZZER_H diff --git a/test/fuzztest/accesstokenid/settokenidcmderror_fuzzer/settokenidcmderror_fuzzer.cpp b/test/fuzztest/accesstokenid/settokenidcmderror_fuzzer/settokenidcmderror_fuzzer.cpp index 37851e069437b857a1c7dbf629b6adab8e8f5002..9292c1f22f9d30c3225243215dd0c9b9c2a1d9b8 100644 --- a/test/fuzztest/accesstokenid/settokenidcmderror_fuzzer/settokenidcmderror_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/settokenidcmderror_fuzzer/settokenidcmderror_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #define CMDERROR #include "accesstokenidcommon.h" @@ -22,13 +25,7 @@ using namespace OHOS::Kernel::AccessToken; namespace OHOS { bool SetTokenidCmdErrorFuzzTest(const uint8_t *data, size_t size) { - bool ret = false; - if ((data == nullptr) || (size < sizeof(unsigned long long))) { - return ret; - } else { - unsigned long long tokenId = *(reinterpret_cast(data)); - ret = SetTokenid(&tokenId); - } + bool ret = SetTokenidCmdFuzzTest(data, size); return ret; } } diff --git a/test/fuzztest/accesstokenid/settokenidnullptr_fuzzer/settokenidnullptr_fuzzer.cpp b/test/fuzztest/accesstokenid/settokenidnullptr_fuzzer/settokenidnullptr_fuzzer.cpp index 715454c97a7f05d5db7c2afaf7e9c978afb70878..b8fa5eaacf5aec182ff9a41829d578c4e0f79522 100644 --- a/test/fuzztest/accesstokenid/settokenidnullptr_fuzzer/settokenidnullptr_fuzzer.cpp +++ b/test/fuzztest/accesstokenid/settokenidnullptr_fuzzer/settokenidnullptr_fuzzer.cpp @@ -16,6 +16,9 @@ */ #include +#include +#include +#include "__config" #include "accesstokenidcommon.h" using namespace std; diff --git a/test/fuzztest/accesstokenid/src/accessftokenidcommon.cpp b/test/fuzztest/accesstokenid/src/accessftokenidcommon.cpp deleted file mode 100644 index 6fa504faad6fa345b43a814d1989b6f63c258a94..0000000000000000000000000000000000000000 --- a/test/fuzztest/accesstokenid/src/accessftokenidcommon.cpp +++ /dev/null @@ -1,195 +0,0 @@ -/* - * Copyright (c) 2022 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "accessftokenidcommon.h" - -namespace OHOS { -namespace Kernel { -namespace AccessToken { -const char *DEVACCESSTOKENID = "/dev/access_token_id"; - -int GetfTokenid(unsigned long long *ftoken) -{ - int fd = open(DEVACCESSTOKENID, O_RDWR); - if (fd < 0) { - return -1; - } - - int ret = ioctl(fd, ACCESS_TOKENID_GET_FTOKENID, ftoken); - if (ret) { - close(fd); - return -1; - } - - close(fd); - return 0; -} - -int SetfTokenid(unsigned long long *ftoken) -{ - int fd = open(DEVACCESSTOKENID, O_RDWR); - if (fd < 0) { - return -1; - } - - int ret = ioctl(fd, ACCESS_TOKENID_SET_FTOKENID, ftoken); - if (ret) { - close(fd); - return -1; - } - - close(fd); - return 0; -} - -void SetUidAndGrp() -{ - int ret = 0; - size_t groupListSize = LIST_NUM_2; - gid_t groupList[LIST_NUM_2] = {ACCESS_TOKEN_GRPID, TEST_VALUE}; - - ret = setgroups(groupListSize, groupList); - if (ret != 0) { - return; - } - - ret = setuid(ACCESS_TOKEN_UID); - if (ret != 0) { - printf("SetUidAndGrp setuid error %d \n", ret); - } - - return; -} - -void SetUidAndGrpOther() -{ - int ret = 0; - size_t groupListSize = LIST_NUM_1; - gid_t groupList[LIST_NUM_1] = {ACCESS_TOKEN_OTHER_GRPID}; - - ret = setgroups(groupListSize, groupList); - if (ret != 0) { - return; - } - - ret = setuid(ACCESS_TOKEN_OTHER_UID); - if (ret != 0) { - printf("SetUidAndGrp setuid error %d \r\n", ret); - } - - return; -} - -void SetRandfTokenAndCheck(unsigned long long *data_ftoken) -{ - pid_t pid = getpid(); - pid_t tid = syscall(__NR_gettid); - unsigned long long ftoken = INVAL_TOKEN; - unsigned long long ftokenSet = *data_ftoken; - - SetfTokenid(&ftokenSet); - GetfTokenid(&ftoken); - - if (ftoken != ftokenSet) { - printf("pid:%d tid:%d ftoken test failed, ftoken:%llu ftokenSet:%llu\n", - pid, tid, ftoken, ftokenSet); - } else { - printf("pid:%d tid:%d ftoken test succeed, ftoken:%llu ftokenSet:%llu\n", - pid, tid, ftoken, ftokenSet); - } - - sleep(WAIT_FOR_SHELL_OP_TIME); - - GetfTokenid(&ftoken); - if (ftoken != ftokenSet) { - printf("pid:%d tid:%d ftoken test failed, ftoken:%llu ftokenSet:%llu\n", - pid, tid, ftoken, ftokenSet); - } else { - printf("pid:%d tid:%d ftoken test succeed, ftoken:%llu ftokenSet:%llu\n", - pid, tid, ftoken, ftokenSet); - } - return; -} - -void *fTokenTest(void *data_ftoken) -{ - SetRandfTokenAndCheck(static_cast(data_ftoken)); - return nullptr; -} - -void ThreadTest(void *data_ftoken) -{ - pthread_t id_1; - pthread_t id_2; - pthread_t id_3; - int ret = 0; - - ret = pthread_create(&id_1, nullptr, fTokenTest, data_ftoken); - if (ret != 0) { - return; - } - - ret = pthread_create(&id_2, nullptr, fTokenTest, data_ftoken); - if (ret != 0) { - return; - } - - ret = pthread_create(&id_3, nullptr, fTokenTest, data_ftoken); - if (ret != 0) { - return; - } - - pthread_join(id_1, nullptr); - pthread_join(id_2, nullptr); - pthread_join(id_3, nullptr); - - return; -} - -int AccessfTokenidThreadTest(uint8_t *data_ftoken) -{ - fTokenTest(static_cast(data_ftoken)); - ThreadTest(static_cast(data_ftoken)); - return 0; -} - -int AccessfTokenidGrpTest(uint8_t *data_ftoken) -{ - SetUidAndGrp(); - fTokenTest(static_cast(data_ftoken)); - ThreadTest(static_cast(data_ftoken)); - return 0; -} - -int AccessfTokenidGrpTestOther(uint8_t *data_ftoken) -{ - SetUidAndGrpOther(); - fTokenTest(static_cast(data_ftoken)); - ThreadTest(static_cast(data_ftoken)); - return 0; -} -} // namespace AccessToken -} // namespace Kernel -} // namespace OHOS diff --git a/test/fuzztest/accesstokenid/src/accesstokenidcommon.cpp b/test/fuzztest/accesstokenid/src/accesstokenidcommon.cpp index 1be96bd699a01d96b74c69a88b62d2a35a13e323..18a28cde00436157917af3bb3f5e2c30cd8c8b32 100644 --- a/test/fuzztest/accesstokenid/src/accesstokenidcommon.cpp +++ b/test/fuzztest/accesstokenid/src/accesstokenidcommon.cpp @@ -13,16 +13,13 @@ * limitations under the License. */ -#include -#include -#include -#include -#include -#include #include #include -#include -#include +#include +#include +#include +#include +#include #include "accesstokenidcommon.h" namespace OHOS { @@ -187,6 +184,148 @@ int AccessTokenidGrpTestOther(uint8_t *data_token) ThreadTest(static_cast(data_token)); return 0; } + +int GetfTokenid(unsigned long long *ftoken) +{ + int fd = open(DEVACCESSTOKENID, O_RDWR); + if (fd < 0) { + return -1; + } + + int ret = ioctl(fd, ACCESS_TOKENID_GET_FTOKENID, ftoken); + if (ret) { + close(fd); + return -1; + } + + close(fd); + return 0; +} + +int SetfTokenid(unsigned long long *ftoken) +{ + int fd = open(DEVACCESSTOKENID, O_RDWR); + if (fd < 0) { + return -1; + } + + int ret = ioctl(fd, ACCESS_TOKENID_SET_FTOKENID, ftoken); + if (ret) { + close(fd); + return -1; + } + + close(fd); + return 0; +} + +void SetRandfTokenAndCheck(unsigned long long *data_ftoken) +{ + pid_t pid = getpid(); + pid_t tid = syscall(__NR_gettid); + unsigned long long ftoken = INVAL_TOKEN; + unsigned long long ftokenSet = *data_ftoken; + + SetfTokenid(&ftokenSet); + GetfTokenid(&ftoken); + + if (ftoken != ftokenSet) { + printf("pid:%d tid:%d ftoken test failed, ftoken:%llu ftokenSet:%llu\n", + pid, tid, ftoken, ftokenSet); + } else { + printf("pid:%d tid:%d ftoken test succeed, ftoken:%llu ftokenSet:%llu\n", + pid, tid, ftoken, ftokenSet); + } + + sleep(WAIT_FOR_SHELL_OP_TIME); + + GetfTokenid(&ftoken); + if (ftoken != ftokenSet) { + printf("pid:%d tid:%d ftoken test failed, ftoken:%llu ftokenSet:%llu\n", + pid, tid, ftoken, ftokenSet); + } else { + printf("pid:%d tid:%d ftoken test succeed, ftoken:%llu ftokenSet:%llu\n", + pid, tid, ftoken, ftokenSet); + } + return; +} + +void *fTokenTest(void *data_ftoken) +{ + SetRandfTokenAndCheck(static_cast(data_ftoken)); + return nullptr; +} + +int AccessfTokenidThreadTest(uint8_t *data_ftoken) +{ + fTokenTest(static_cast(data_ftoken)); + ThreadTest(static_cast(data_ftoken)); + return 0; +} + +int AccessfTokenidGrpTest(uint8_t *data_ftoken) +{ + SetUidAndGrp(); + fTokenTest(static_cast(data_ftoken)); + ThreadTest(static_cast(data_ftoken)); + return 0; +} + +int AccessfTokenidGrpTestOther(uint8_t *data_ftoken) +{ + SetUidAndGrpOther(); + fTokenTest(static_cast(data_ftoken)); + ThreadTest(static_cast(data_ftoken)); + return 0; +} + +bool SetfTokenidCmdFuzzTest(const uint8_t *data, size_t size) +{ + bool ret = false; + if ((data == nullptr) || (size < sizeof(unsigned long long))) { + return ret; + } else { + unsigned long long tokenId = *(reinterpret_cast(data)); + ret = SetfTokenid(&tokenId); + } + return ret; +} + +bool GetfTokenidCmdFuzzTest(const uint8_t *data, size_t size) +{ + bool ret = false; + if ((data == nullptr) || (size < sizeof(unsigned long long))) { + return ret; + } else { + unsigned long long tokenId = *(reinterpret_cast(data)); + ret = GetfTokenid(&tokenId); + } + return ret; +} + +bool GetTokenidCmdFuzzTest(const uint8_t *data, size_t size) +{ + bool ret = false; + if ((data == nullptr) || (size < sizeof(unsigned long long))) { + return ret; + } else { + unsigned long long tokenId = *(reinterpret_cast(data)); + ret = GetTokenid(&tokenId); + } + return ret; +} + +bool SetTokenidCmdFuzzTest(const uint8_t *data, size_t size) +{ + bool ret = false; + if ((data == nullptr) || (size < sizeof(unsigned long long))) { + return ret; + } else { + unsigned long long tokenId = *(reinterpret_cast(data)); + ret = SetTokenid(&tokenId); + } + return ret; +} } // namespace AccessToken } // namespace Kernel } // namespace OHOS diff --git a/test/fuzztest/hc_node/hcenable_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hcenable_fuzzer/BUILD.gn index d2edc284413c9fd5bee27e37d57a04202f6a0d57..dcc34f46eb175a6d5a8004103ac539eb2b5a29ee 100644 --- a/test/fuzztest/hc_node/hcenable_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hcenable_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("HcEnableFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hcenable_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hcenable_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hcenable_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/hc_node/hcenable_fuzzer/hcenable_fuzzer.cpp b/test/fuzztest/hc_node/hcenable_fuzzer/hcenable_fuzzer.cpp index 7c7c9f0e399662e5014e4c540f0c66d176e4e3f8..c1bb408fbc45eb70dbc8f097f9b1a42016b70bf8 100644 --- a/test/fuzztest/hc_node/hcenable_fuzzer/hcenable_fuzzer.cpp +++ b/test/fuzztest/hc_node/hcenable_fuzzer/hcenable_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_ENABLE = "/sys/fs/f2fs/loop1/hc_enable"; namespace OHOS { bool HcEnableFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_ENABLE, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_ENABLE); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_ENABLE, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/BUILD.gn index dc889e81f51aff9f36451443334aa72e454e8ff9..9351847ed4d3919d2ccf5cb888278792c2b9f392 100644 --- a/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("HcHotDataLowerLimitFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hchotdatalowerlimit_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hchotdatalowerlimit_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/hchotdatalowerlimit_fuzzer.cpp b/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/hchotdatalowerlimit_fuzzer.cpp index 8a1af0c376f8c3c8237c2a1b0e168e8c297c9f3f..12960c3f63e9412ec9ae10e286893b2758d5d11b 100644 --- a/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/hchotdatalowerlimit_fuzzer.cpp +++ b/test/fuzztest/hc_node/hchotdatalowerlimit_fuzzer/hchotdatalowerlimit_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_HOT_DATA_LOWER_LIMIT = "/sys/fs/f2fs/loop1/hc_hot_data_lower_limit"; namespace OHOS { bool HcHotDataLowerLimitFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_HOT_DATA_LOWER_LIMIT, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_HOT_DATA_LOWER_LIMIT); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_HOT_DATA_LOWER_LIMIT, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/hc_node/hchotdatawaterline_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hchotdatawaterline_fuzzer/BUILD.gn index ba64e31647d4f5dfd347a3455f279b825272a599..aa7205f04d07b5b8e2e06f7e692c074942713f4e 100644 --- a/test/fuzztest/hc_node/hchotdatawaterline_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hchotdatawaterline_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("HcHotDataWaterlineFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hchotdatawaterline_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hchotdatawaterline_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hchotdatawaterline_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/hc_node/hchotdatawaterline_fuzzer/hchotdatawaterline_fuzzer.cpp b/test/fuzztest/hc_node/hchotdatawaterline_fuzzer/hchotdatawaterline_fuzzer.cpp index 189b67b6399f09f93c91fac02540dafc080c3d62..6630f76d8a5a015c8f4b8c87de3998a20478997f 100644 --- a/test/fuzztest/hc_node/hchotdatawaterline_fuzzer/hchotdatawaterline_fuzzer.cpp +++ b/test/fuzztest/hc_node/hchotdatawaterline_fuzzer/hchotdatawaterline_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_HOT_DATA_WATERLINE = "/sys/fs/f2fs/loop1/hc_hot_data_waterline"; namespace OHOS { bool HcHotDataWaterlineFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_HOT_DATA_WATERLINE, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_HOT_DATA_WATERLINE); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_HOT_DATA_WATERLINE, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/BUILD.gn index 2ff4a14c5637fa87cfec535d7d3ec0145e778c05..a7f3a19a3645733aece74b11276e0b4c679384f9 100644 --- a/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("HcHotNodeLowerLimitFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hchotnodelowerlimit_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hchotnodelowerlimit_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/hchotnodelowerlimit_fuzzer.cpp b/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/hchotnodelowerlimit_fuzzer.cpp index 5799c61c7c09a236ebedc3b99d08dd78fba238f4..9e38b731a3e572b4d1488072b139953fb69af0ba 100644 --- a/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/hchotnodelowerlimit_fuzzer.cpp +++ b/test/fuzztest/hc_node/hchotnodelowerlimit_fuzzer/hchotnodelowerlimit_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_HOT_NODE_LOWER_LIMIT = "/sys/fs/f2fs/loop1/hc_hot_node_lower_limit"; namespace OHOS { bool HcHotNodeLowerLimitFuzzTest(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_HOT_NODE_LOWER_LIMIT, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_HOT_NODE_LOWER_LIMIT); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_HOT_NODE_LOWER_LIMIT, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/hc_node/hchotnodewaterline_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hchotnodewaterline_fuzzer/BUILD.gn index f31385874a9b6083cd6d91b7cb73d8e42bc23fc4..c3df58b01fad35e3ecf60dddcbb0de4f60073cdc 100644 --- a/test/fuzztest/hc_node/hchotnodewaterline_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hchotnodewaterline_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("HcHotNodeWaterLineFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hchotnodewaterline_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hchotnodewaterline_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hchotnodewaterline_fuzzer.cpp", + ] } group("fuzztest") { testonly = true diff --git a/test/fuzztest/hc_node/hchotnodewaterline_fuzzer/hchotnodewaterline_fuzzer.cpp b/test/fuzztest/hc_node/hchotnodewaterline_fuzzer/hchotnodewaterline_fuzzer.cpp index 2ef9b15343db670326512f975da9b1f78954e6b6..b0099335a66df1a6fcea9f062a0548556bff2390 100644 --- a/test/fuzztest/hc_node/hchotnodewaterline_fuzzer/hchotnodewaterline_fuzzer.cpp +++ b/test/fuzztest/hc_node/hchotnodewaterline_fuzzer/hchotnodewaterline_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_HOT_NODE_WATERLINE = "/sys/fs/f2fs/loop1/hc_hot_node_waterline"; namespace OHOS { bool HcHotNodeWaterlineFuzzTest(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_HOT_NODE_WATERLINE, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_HOT_NODE_WATERLINE); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_HOT_NODE_WATERLINE, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/BUILD.gn index 2a1f7fe48ba897e73f7e0e3dcb4f6194dfcfbe26..fa0a7a5aaf488a66c468fdadfff4d81371dc5ad9 100644 --- a/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/BUILD.gn @@ -20,13 +20,18 @@ ohos_fuzztest("HcWarmDataLowerLimitFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hcwarmdatalowerlimit_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hcwarmdatalowerlimit_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/hcwarmdatalowerlimit_fuzzer.cpp b/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/hcwarmdatalowerlimit_fuzzer.cpp index 9691fbaa026633f9d49adee860a7eb893d48f01a..0c51cf92ad77fb6cebf9d57a95cc00101fad748c 100644 --- a/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/hcwarmdatalowerlimit_fuzzer.cpp +++ b/test/fuzztest/hc_node/hcwarmdatalowerlimit_fuzzer/hcwarmdatalowerlimit_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_WARM_DATA_LOWER_LIMIT = "/sys/fs/f2fs/loop1/hc_warm_data_lower_limit"; namespace OHOS { bool HcWarmDataLowerLimitFuzzTest(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_WARM_DATA_LOWER_LIMIT, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_WARM_DATA_LOWER_LIMIT); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_WARM_DATA_LOWER_LIMIT, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/BUILD.gn index 76517cb8d525ffa8f858b0861c88113b57c81ad8..aff74490a4ee16d06a712269eb95430c5c3c70bd 100644 --- a/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/BUILD.gn @@ -20,13 +20,18 @@ ohos_fuzztest("HcWarmDataWaterLineFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hcwarmdatawaterline_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hcwarmdatawaterline_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/hcwarmdatawaterline_fuzzer.cpp b/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/hcwarmdatawaterline_fuzzer.cpp index 040152f8453c07c18f5e669a897f3b78ebbae7af..ff0684b9d9d126435f2423ac30aa0ee73bd4f774 100644 --- a/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/hcwarmdatawaterline_fuzzer.cpp +++ b/test/fuzztest/hc_node/hcwarmdatawaterline_fuzzer/hcwarmdatawaterline_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_WARM_DATA_WATERLINE = "/sys/fs/f2fs/loop1/hc_warm_data_waterline"; namespace OHOS { bool HcWarmDataWaterLineFuzzTest(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_WARM_DATA_WATERLINE, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_WARM_DATA_WATERLINE); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_WARM_DATA_WATERLINE, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/BUILD.gn index 11d6cbfbd783b243255bb9ae63a7d87e812cd5b7..23ca923cd1b0adfdeeb11ea8ae0ca225aa35bbf5 100644 --- a/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("HcWarmNodeLowerLimitFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hcwarmnodelowerlimit_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hcwarmnodelowerlimit_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/hcwarmnodelowerlimit_fuzzer.cpp b/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/hcwarmnodelowerlimit_fuzzer.cpp index e5d3b2315c9be5ea228f89adabe215a958d0c176..ebb10deb41c0d846dedbc2ecb3b21e0f8520713f 100644 --- a/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/hcwarmnodelowerlimit_fuzzer.cpp +++ b/test/fuzztest/hc_node/hcwarmnodelowerlimit_fuzzer/hcwarmnodelowerlimit_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_WARM_NODE_LOWER_LIMIT = "/sys/fs/f2fs/loop1/hc_warm_node_lower_limit"; namespace OHOS { bool HcWarmNodeLowerLimit(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_WARM_NODE_LOWER_LIMIT, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_WARM_NODE_LOWER_LIMIT); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_WARM_NODE_LOWER_LIMIT, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/BUILD.gn b/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/BUILD.gn index 82873d4ac586384a52178f6522838403b9d7f09b..ad8bf35e770404389d4f1eef025d846dba347c04 100644 --- a/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/BUILD.gn +++ b/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/BUILD.gn @@ -20,13 +20,18 @@ ohos_fuzztest("HcWarmNodeWaterLineFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "hcwarmnodewaterline_fuzzer.cpp" ] + sources = [ + "../src/hccommon.cpp", + "hcwarmnodewaterline_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/hcwarmnodewaterline_fuzzer.cpp b/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/hcwarmnodewaterline_fuzzer.cpp index 4c19bc2767b246c728eed4361a19c7839d3690d0..a9603a7e4d9ccc82204a69b6c04ef8c120f266ed 100644 --- a/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/hcwarmnodewaterline_fuzzer.cpp +++ b/test/fuzztest/hc_node/hcwarmnodewaterline_fuzzer/hcwarmnodewaterline_fuzzer.cpp @@ -15,46 +15,15 @@ #include #include -#include -#include -#include -#include -#include +#include "hccommon.h" const char *HC_WARM_NODE_WATERLINE = "/sys/fs/f2fs/loop1/hc_warm_node_waterline"; namespace OHOS { bool HcWarmNodeLowerWaterLine(const uint8_t *data, size_t size) { - uint32_t value = 0; - uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; - int ret = access("/mnt/f2fs_mount/", F_OK); - if (ret < 0) { - system("mkdir -p /mnt/f2fs_mount/"); - system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); - system("losetup /dev/block/loop1 /data/image_f2fs"); - system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); - } - - int fd = open(HC_WARM_NODE_WATERLINE, O_RDWR); - if (fd < 0) { - return false; - } - - ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", HC_WARM_NODE_WATERLINE); - close(fd); - return false; - } - - ret = write(fd, data, length); - if (ret < 0) { - close(fd); - return false; - } - close(fd); - return true; + bool ret = HcFuzzTest(data, HC_WARM_NODE_WATERLINE, size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/accesstokenid/settokenidcmderror_fuzzer/settokenidcmderror_fuzzer.h b/test/fuzztest/hc_node/include/hccommon.h similarity index 74% rename from test/fuzztest/accesstokenid/settokenidcmderror_fuzzer/settokenidcmderror_fuzzer.h rename to test/fuzztest/hc_node/include/hccommon.h index 78627a818e0a8220da26d642ebe2fc4fde28daa5..31f790c08e539916efaf75b457ad67730fb35614 100644 --- a/test/fuzztest/accesstokenid/settokenidcmderror_fuzzer/settokenidcmderror_fuzzer.h +++ b/test/fuzztest/hc_node/include/hccommon.h @@ -13,9 +13,11 @@ * limitations under the License. */ -#ifndef TEST_FUZZTEST_SETTOKENIDCMDERROR_FUZZER_H -#define TEST_FUZZTEST_SETTOKENIDCMDERROR_FUZZER_H +#ifndef HCCOMMON_H +#define HCCOMMON_H -#define FUZZ_PROJECT_NAME "settokenidcmderror_fuzzer" +namespace OHOS { +bool HcFuzzTest(const uint8_t *data, const char *pathname, size_t size); +} -#endif // TEST_FUZZTEST_SETTOKENIDCMDERROR_FUZZER_H +#endif \ No newline at end of file diff --git a/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/getftokenidcmderror_fuzzer.h b/test/fuzztest/hc_node/src/hccommon.cpp similarity index 39% rename from test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/getftokenidcmderror_fuzzer.h rename to test/fuzztest/hc_node/src/hccommon.cpp index 60a480440c7588d392b2e644b5f8cd8c7e103dbd..fa866bfe4181c26afb1916a94ae9e058930905a2 100644 --- a/test/fuzztest/accesstokenid/getftokenidcmderror_fuzzer/getftokenidcmderror_fuzzer.h +++ b/test/fuzztest/hc_node/src/hccommon.cpp @@ -13,9 +13,43 @@ * limitations under the License. */ -#ifndef TEST_FUZZTEST_GETFTOKENIDCMDERROR_FUZZER_H -#define TEST_FUZZTEST_GETFTOKENIDCMDERROR_FUZZER_H +#include +#include +#include +#include +#include +#include "hccommon.h" -#define FUZZ_PROJECT_NAME "getftokenidcmderror_fuzzer" +namespace OHOS { +bool HcFuzzTest(const uint8_t *data, const char *pathname, size_t size) +{ + uint32_t value = 0; + uint32_t length = size > sizeof(uint32_t) ? sizeof(uint32_t) : size; + int ret = access("/mnt/f2fs_mount/", F_OK); + if (ret < 0) { + system("mkdir -p /mnt/f2fs_mount/"); + system("mkfs.f2fs -d1 -t1 -O quota /data/image_f2fs"); + system("losetup /dev/block/loop1 /data/image_f2fs"); + system("mount -t f2fs /dev/block/loop1 /mnt/f2fs_mount/"); + } -#endif // TEST_FUZZTEST_GETFTOKENIDCMDERROR_FUZZER_H + int fd = open(pathname, O_RDWR); + if (fd < 0) { + return false; + } + + ret = read(fd, &value, sizeof(value)); + if (ret < 0) { + close(fd); + return false; + } + + ret = write(fd, data, length); + if (ret < 0) { + close(fd); + return false; + } + close(fd); + return true; +} +} \ No newline at end of file diff --git a/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/BUILD.gn b/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/BUILD.gn index 1728b2973d601cf0b4208206fa857e897868b54f..b27b7f6c87c728ea5cb5180875f850b1ed45ca01 100644 --- a/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/BUILD.gn @@ -20,13 +20,18 @@ ohos_fuzztest("AnonRefaultSnapshotMinIntervalFuzzTest") { module_out_path = module_output_path fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "anonrefaultsnapshotmininterval_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "anonrefaultsnapshotmininterval_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/anonrefaultsnapshotmininterval_fuzzer.cpp b/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/anonrefaultsnapshotmininterval_fuzzer.cpp index 3d35b90ad43aaadaedb3752776f9653f071337d8..b01933fef42d2c4a1ac115d7bc4149893f5a2f66 100644 --- a/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/anonrefaultsnapshotmininterval_fuzzer.cpp +++ b/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/anonrefaultsnapshotmininterval_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *ANON_REFAULT_SNAPSHOT_MIN_INTERVAL = "/dev/memcg/memory.anon_refault_snapshot_min_interval"; +#include "memorycommon.h" namespace OHOS { bool AnonRefaultSnapshotMinIntervalFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(ANON_REFAULT_SNAPSHOT_MIN_INTERVAL, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", ANON_REFAULT_SNAPSHOT_MIN_INTERVAL); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *anon_refault_snapshot_min_interval = "/dev/memcg/memory.anon_refault_snapshot_min_interval"; + bool ret = MemoryFuzzTest(data, size, anon_refault_snapshot_min_interval); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/appscore_fuzzer/BUILD.gn b/test/fuzztest/memory/appscore_fuzzer/BUILD.gn index 33b823bd6c525305c2ed47da16d86d75eead4333..4cb2e352a88b830c8cebfdd3af9374ae72b4d5d0 100644 --- a/test/fuzztest/memory/appscore_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/appscore_fuzzer/BUILD.gn @@ -20,13 +20,18 @@ ohos_fuzztest("AppScoreFuzzTest") { module_out_path = module_output_path fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/appscore_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "appscore_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "appscore_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/appscore_fuzzer/appscore_fuzzer.cpp b/test/fuzztest/memory/appscore_fuzzer/appscore_fuzzer.cpp index 1896d1b0f0cb72cfa2e0e52e2f5a6d4d63a45cc6..1776020df04efbfe488d1db66e0693c0abf144ba 100644 --- a/test/fuzztest/memory/appscore_fuzzer/appscore_fuzzer.cpp +++ b/test/fuzztest/memory/appscore_fuzzer/appscore_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *APP_SCORE = "/dev/memcg/memory.app_score"; +#include "memorycommon.h" namespace OHOS { bool AppScoreFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(APP_SCORE, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", APP_SCORE); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *app_score = "/dev/memcg/memory.app_score"; + bool ret = MemoryFuzzTest(data, size, app_score); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/BUILD.gn b/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/BUILD.gn index c7fc1a3cb50992520b02cb83b4ad99960216f7a3..6c16381f28e3de7ec2f24cda0046402877f6deec 100644 --- a/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/BUILD.gn @@ -20,13 +20,18 @@ ohos_fuzztest("AreaAnonRefaultThresholdFuzzTest") { module_out_path = module_output_path fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "areaanonrefaultthreshold_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "areaanonrefaultthreshold_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/areaanonrefaultthreshold_fuzzer.cpp b/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/areaanonrefaultthreshold_fuzzer.cpp index fbe1e3c766621345a913942505ac61c8bdd773a7..9d34c76b0ecfa7cd704b40ede6d561d34ce27683 100644 --- a/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/areaanonrefaultthreshold_fuzzer.cpp +++ b/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/areaanonrefaultthreshold_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *AREA_ANON_REFAULT_THRESHOLD = "/dev/memcg/memory.area_anon_refault_threshold"; +#include "memorycommon.h" namespace OHOS { bool AreaAnonRefaultThresholdFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(AREA_ANON_REFAULT_THRESHOLD, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", AREA_ANON_REFAULT_THRESHOLD); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *area_anon_refault_threshold = "/dev/memcg/memory.area_anon_refault_threshold"; + bool ret = MemoryFuzzTest(data, size, area_anon_refault_threshold); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/availbuffers_fuzzer/BUILD.gn b/test/fuzztest/memory/availbuffers_fuzzer/BUILD.gn index 23dc1c71291e8e32e581a6fe9dd75dcac8d68791..9d3e783931aa838593d36aa8540297f85eb0f8d3 100644 --- a/test/fuzztest/memory/availbuffers_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/availbuffers_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("AvailBuffersFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/availbuffers_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "availbuffers_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "availbuffers_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/availbuffers_fuzzer/availbuffers_fuzzer.cpp b/test/fuzztest/memory/availbuffers_fuzzer/availbuffers_fuzzer.cpp index 54ceadd0f6692a49c8ca2f30258cf06eecd9edd4..7baf485a9e289f27fdf7624dc461aa6d72664a69 100644 --- a/test/fuzztest/memory/availbuffers_fuzzer/availbuffers_fuzzer.cpp +++ b/test/fuzztest/memory/availbuffers_fuzzer/availbuffers_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *AVAIL_BUFFERS = "/dev/memcg/memory.avail_buffers"; +#include "memorycommon.h" namespace OHOS { bool AvailBuffersFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(AVAIL_BUFFERS, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", AVAIL_BUFFERS); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *avail_buffers = "/dev/memcg/memory.avail_buffers"; + bool ret = MemoryFuzzTest(data, size, avail_buffers); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/bufferratioparams_fuzzer/BUILD.gn b/test/fuzztest/memory/bufferratioparams_fuzzer/BUILD.gn index 323a77e276b41a4228e14d46e9cc5e6b4289b7ee..81f37a96b9278e2b4001fff2b5f3aa8f2a8d7ebf 100644 --- a/test/fuzztest/memory/bufferratioparams_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/bufferratioparams_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("BufferRatioParamsFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/bufferratioparams_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "bufferratioparams_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "bufferratioparams_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/bufferratioparams_fuzzer/bufferratioparams_fuzzer.cpp b/test/fuzztest/memory/bufferratioparams_fuzzer/bufferratioparams_fuzzer.cpp index e05a1b6e4eeebf219971a08b1ac029e7433c3ec1..e74be4089395d39d8db75a013efa6f6663c7d74c 100644 --- a/test/fuzztest/memory/bufferratioparams_fuzzer/bufferratioparams_fuzzer.cpp +++ b/test/fuzztest/memory/bufferratioparams_fuzzer/bufferratioparams_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *BUFFER_RATIO_PARAMS = "/dev/memcg/memory.buffer_ratio_params"; +#include "memorycommon.h" namespace OHOS { bool BufferRatioParamsFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(BUFFER_RATIO_PARAMS, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", BUFFER_RATIO_PARAMS); - close(fd); - return false; - } - - ret = write(fd, data, sizeof(uint8_t)); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *buffer_ratio_params = "/dev/memcg/memory.buffer_ratio_params"; + bool ret = MemoryFuzzTest(data, size, buffer_ratio_params); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/compressratio_fuzzer/BUILD.gn b/test/fuzztest/memory/compressratio_fuzzer/BUILD.gn index 019dd38a6ff6d812fa29268f4e12b46492276afa..a040fa1957c3e9f28bd098b47f1f62aa64324774 100644 --- a/test/fuzztest/memory/compressratio_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/compressratio_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("CompressRatioFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/compressratio_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "compressratio_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "compressratio_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/compressratio_fuzzer/compressratio_fuzzer.cpp b/test/fuzztest/memory/compressratio_fuzzer/compressratio_fuzzer.cpp index 44a5437dade705c34856986578d935e3e8c8c5e9..0eea7b1786967b3a16443f05690c3aae263defdf 100644 --- a/test/fuzztest/memory/compressratio_fuzzer/compressratio_fuzzer.cpp +++ b/test/fuzztest/memory/compressratio_fuzzer/compressratio_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *COMPRESS_RATIO = "/dev/memcg/memory.compress_ratio"; +#include "memorycommon.h" namespace OHOS { bool CompressRatioFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(COMPRESS_RATIO, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", COMPRESS_RATIO); - close(fd); - return false; - } - - ret = write(fd, data, sizeof(uint8_t)); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *compress_ratio = "/dev/memcg/memory.compress_ratio"; + bool ret = MemoryFuzzTest(data, size, compress_ratio); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/BUILD.gn b/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/BUILD.gn index 7afade9b815670d12d804940fe87dd6b24a044c8..96661e8d26e6eb05ce10ad40d164f85031094090 100644 --- a/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/BUILD.gn @@ -20,13 +20,18 @@ ohos_fuzztest("EmptyRoundCheckThresholdFuzzTest") { module_out_path = module_output_path fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "emptyroundcheckthreshold_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "emptyroundcheckthreshold_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/emptyroundcheckthreshold_fuzzer.cpp b/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/emptyroundcheckthreshold_fuzzer.cpp index a57895aa528934a7d466c937564f01f2f23ae5df..268aaf282652f00ba17fd1c4833c35c73f181856 100644 --- a/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/emptyroundcheckthreshold_fuzzer.cpp +++ b/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/emptyroundcheckthreshold_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *EMPTY_ROUND_CHECK_THRESHOLD = "/dev/memcg/memory.empty_round_check_threshold"; +#include "memorycommon.h" namespace OHOS { bool EmptyRoundCheckThresholdFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(EMPTY_ROUND_CHECK_THRESHOLD, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", EMPTY_ROUND_CHECK_THRESHOLD); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *empty_round_check_threshold = "/dev/memcg/memory.empty_round_check_threshold"; + bool ret = MemoryFuzzTest(data, size, empty_round_check_threshold); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/emptyroundskipinterval_fuzzer/BUILD.gn b/test/fuzztest/memory/emptyroundskipinterval_fuzzer/BUILD.gn index 4d456e8a0b2733484637fd32ccb49a1594d44404..6c5b64254a3bb53b0b7270da9dd3d5173e6f8e3c 100644 --- a/test/fuzztest/memory/emptyroundskipinterval_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/emptyroundskipinterval_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("EmptyRoundSkipIntervalFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/emptyroundskipinterval_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "emptyroundskipinterval_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "emptyroundskipinterval_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/emptyroundskipinterval_fuzzer/emptyroundskipinterval_fuzzer.cpp b/test/fuzztest/memory/emptyroundskipinterval_fuzzer/emptyroundskipinterval_fuzzer.cpp index 787aa5f924d6df7bace3164479dd80b2121294d9..d053acee263b148a2e55ae4797ff61230cadae7f 100644 --- a/test/fuzztest/memory/emptyroundskipinterval_fuzzer/emptyroundskipinterval_fuzzer.cpp +++ b/test/fuzztest/memory/emptyroundskipinterval_fuzzer/emptyroundskipinterval_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *EMPTY_ROUND_SKIP_INTERVAL = "/dev/memcg/memory.empty_round_skip_interval"; +#include "memorycommon.h" namespace OHOS { bool EmptyRoundSkipIntervalFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(EMPTY_ROUND_SKIP_INTERVAL, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", EMPTY_ROUND_SKIP_INTERVAL); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *empty_round_skip_interval = "/dev/memcg/memory.empty_round_skip_interval"; + bool ret = MemoryFuzzTest(data, size, empty_round_skip_interval); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/forceshrinkanon_fuzzer/BUILD.gn b/test/fuzztest/memory/forceshrinkanon_fuzzer/BUILD.gn index 08e9c7a8e4cfcb61cde1ab35eea1925251823527..83ca3a99ddad4975c84f07a467078b1cc3d37b0a 100644 --- a/test/fuzztest/memory/forceshrinkanon_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/forceshrinkanon_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("ForceShrinkAnonFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/forceshrinkanon_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "forceshrinkanon_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "forceshrinkanon_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/forceshrinkanon_fuzzer/forceshrinkanon_fuzzer.cpp b/test/fuzztest/memory/forceshrinkanon_fuzzer/forceshrinkanon_fuzzer.cpp index 6725fe7e1196b69ff8aa146dd5da8874b439b420..9dcaa00c1d3423f9fd1d7b19b7a889167f57e61f 100644 --- a/test/fuzztest/memory/forceshrinkanon_fuzzer/forceshrinkanon_fuzzer.cpp +++ b/test/fuzztest/memory/forceshrinkanon_fuzzer/forceshrinkanon_fuzzer.cpp @@ -13,27 +13,25 @@ * limitations under the License. */ +#include #include #include -#include -#include -#include -#include #include - -const char *FORCE_SHRINK_ANON = "/dev/memcg/memory.force_shrink_anon"; +#include +#include "memorycommon.h" namespace OHOS { bool ForceShrinkAnonFuzzer(const uint8_t *data, size_t size) { - int fd = open(FORCE_SHRINK_ANON, O_RDWR); + const char *force_shrink_anon = "/dev/memcg/memory.force_shrink_anon"; + int fd = open(force_shrink_anon, O_RDWR); if (fd < 0) { return false; } int ret = write(fd, data, size); if (ret < 0) { - printf("%s write fail\n", FORCE_SHRINK_ANON); + printf("%s write fail\n", force_shrink_anon); close(fd); return false; } diff --git a/test/fuzztest/accesstokenid/gettokenidcmderror_fuzzer/gettokenidcmderror_fuzzer.h b/test/fuzztest/memory/include/memorycommon.h similarity index 74% rename from test/fuzztest/accesstokenid/gettokenidcmderror_fuzzer/gettokenidcmderror_fuzzer.h rename to test/fuzztest/memory/include/memorycommon.h index 05459560403be0fc8753911f1a381a7b49718a8e..7e90286324d07d112b658b1994827f31dfdf3e2d 100644 --- a/test/fuzztest/accesstokenid/gettokenidcmderror_fuzzer/gettokenidcmderror_fuzzer.h +++ b/test/fuzztest/memory/include/memorycommon.h @@ -13,9 +13,11 @@ * limitations under the License. */ -#ifndef TEST_FUZZTEST_GETTOKENIDCMDERROR_FUZZER_H -#define TEST_FUZZTEST_GETTOKENIDCMDERROR_FUZZER_H +#ifndef MEMORYCOMMON_H +#define MEMORYCOMMON_H -#define FUZZ_PROJECT_NAME "gettokenidcmderror_fuzzer" +namespace OHOS { +bool MemoryFuzzTest(const uint8_t *data, size_t size, const char *pathname); +} -#endif // TEST_FUZZTEST_GETTOKENIDCMDERROR_FUZZER_H +#endif \ No newline at end of file diff --git a/test/fuzztest/memory/maxskipinterval_fuzzer/BUILD.gn b/test/fuzztest/memory/maxskipinterval_fuzzer/BUILD.gn index f5273cde45915741f49939e71c137b59dfe0e250..dd186d5b13897624c2d3bafcd9e7827c1873a0c9 100644 --- a/test/fuzztest/memory/maxskipinterval_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/maxskipinterval_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("MaxSkipIntervalFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/maxskipinterval_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "maxskipinterval_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "maxskipinterval_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/maxskipinterval_fuzzer/maxskipinterval_fuzzer.cpp b/test/fuzztest/memory/maxskipinterval_fuzzer/maxskipinterval_fuzzer.cpp index f87096bd48d1fd5bae280b35761833ebd195f747..d5e8c1561b990fd8115bd586bd5784e73592132e 100644 --- a/test/fuzztest/memory/maxskipinterval_fuzzer/maxskipinterval_fuzzer.cpp +++ b/test/fuzztest/memory/maxskipinterval_fuzzer/maxskipinterval_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *MAX_SKIP_INTERVAL = "/dev/memcg/memory.max_skip_interval"; +#include "memorycommon.h" namespace OHOS { bool MaxSkipIntervalFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(MAX_SKIP_INTERVAL, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", MAX_SKIP_INTERVAL); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *max_skip_interval = "/dev/memcg/memory.max_skip_interval"; + bool ret = MemoryFuzzTest(data, size, max_skip_interval); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/name_fuzzer/BUILD.gn b/test/fuzztest/memory/name_fuzzer/BUILD.gn index b49cc4ec975612550281af65a0ab84e9bfa0e776..f73cf5ca3177c161c385c07d813fe9e3c28912c4 100644 --- a/test/fuzztest/memory/name_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/name_fuzzer/BUILD.gn @@ -20,13 +20,18 @@ ohos_fuzztest("NameFuzzTest") { module_out_path = module_output_path fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/name_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "name_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "name_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/name_fuzzer/name_fuzzer.cpp b/test/fuzztest/memory/name_fuzzer/name_fuzzer.cpp index d8fe0e50a1a4f832457e6c1aaf5a7bf73e8335e4..9311f4d0775b5b2fbd892005cea09364f705a3d9 100644 --- a/test/fuzztest/memory/name_fuzzer/name_fuzzer.cpp +++ b/test/fuzztest/memory/name_fuzzer/name_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *NAME = "/dev/memcg/memory.name"; +#include "memorycommon.h" namespace OHOS { bool NameFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(NAME, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", NAME); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *name = "/dev/memcg/memory.name"; + bool ret = MemoryFuzzTest(data, size, name); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/getftokenidcmdcorrect_fuzzer.h b/test/fuzztest/memory/src/memorycommon.cpp similarity index 52% rename from test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/getftokenidcmdcorrect_fuzzer.h rename to test/fuzztest/memory/src/memorycommon.cpp index 314fb9de7c525f6c9b9f505e443a65ef65167b32..82e2dfbdcdfdb0d54b96b3e61a010402fc33e450 100644 --- a/test/fuzztest/accesstokenid/getftokenidcmdcorrect_fuzzer/getftokenidcmdcorrect_fuzzer.h +++ b/test/fuzztest/memory/src/memorycommon.cpp @@ -13,9 +13,35 @@ * limitations under the License. */ -#ifndef TEST_FUZZTEST_GETFTOKENIDCMDCORRECT_FUZZER_H -#define TEST_FUZZTEST_GETFTOKENIDCMDCORRECT_FUZZER_H +#include +#include +#include +#include +#include "memorycommon.h" -#define FUZZ_PROJECT_NAME "getftokenidcmdcorrect_fuzzer" +namespace OHOS { +bool MemoryFuzzTest(const uint8_t *data, size_t size, const char *pathname) +{ + uint32_t value = 0; -#endif // TEST_FUZZTEST_GETFTOKENIDCMDCORRECT_FUZZER_H + int fd = open(pathname, O_RDWR); + if (fd < 0) { + return false; + } + + int ret = read(fd, &value, sizeof(value)); + if (ret < 0) { + close(fd); + return false; + } + + ret = write(fd, data, size); + if (ret < 0) { + close(fd); + return false; + } + + close(fd); + return true; +} +} \ No newline at end of file diff --git a/test/fuzztest/memory/ubufs2zramratio_fuzzer/BUILD.gn b/test/fuzztest/memory/ubufs2zramratio_fuzzer/BUILD.gn index 88cd1ae553c03a8da1a7984ef132fe3c97af68e6..dcd7589a0f681152eecae04613e95884aedbb235 100644 --- a/test/fuzztest/memory/ubufs2zramratio_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/ubufs2zramratio_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("UbUfs2zramRatioFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/ubufs2zramratio_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "ubufs2zramratio_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "ubufs2zramratio_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/ubufs2zramratio_fuzzer/ubufs2zramratio_fuzzer.cpp b/test/fuzztest/memory/ubufs2zramratio_fuzzer/ubufs2zramratio_fuzzer.cpp index a8ab055498fee0701279e2886b27c688685c06f2..505e8d01d287c977181c006e8c9342406bdce97f 100644 --- a/test/fuzztest/memory/ubufs2zramratio_fuzzer/ubufs2zramratio_fuzzer.cpp +++ b/test/fuzztest/memory/ubufs2zramratio_fuzzer/ubufs2zramratio_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *UB_UFS2ZRAM_RATIO = "/dev/memcg/memory.ub_ufs2zram_ratio"; +#include "memorycommon.h" namespace OHOS { bool UbUfs2zramRatioFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(UB_UFS2ZRAM_RATIO, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", UB_UFS2ZRAM_RATIO); - close(fd); - return false; - } - - ret = write(fd, data, sizeof(uint8_t)); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *ub_ufs2zram_ratio = "/dev/memcg/memory.ub_ufs2zram_ratio"; + bool ret = MemoryFuzzTest(data, size, ub_ufs2zram_ratio); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/zramcriticalthreshold_fuzzer/BUILD.gn b/test/fuzztest/memory/zramcriticalthreshold_fuzzer/BUILD.gn index 6c3c462c567d1e257743a7ae1895dbab39bf4c0e..f41f4bd211882a94e9a3c417026dcbf91517e1b6 100644 --- a/test/fuzztest/memory/zramcriticalthreshold_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/zramcriticalthreshold_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("ZramCriticalThresholdFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/zramcriticalthreshold_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "zramcriticalthreshold_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "zramcriticalthreshold_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/zramcriticalthreshold_fuzzer/zramcriticalthreshold_fuzzer.cpp b/test/fuzztest/memory/zramcriticalthreshold_fuzzer/zramcriticalthreshold_fuzzer.cpp index 5fc1675b196d66a8f6245f3782390f3b4cba492a..32c4692211998bd39ce7e4016b2d093a36b891d9 100644 --- a/test/fuzztest/memory/zramcriticalthreshold_fuzzer/zramcriticalthreshold_fuzzer.cpp +++ b/test/fuzztest/memory/zramcriticalthreshold_fuzzer/zramcriticalthreshold_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *ZRAM_CRITICAL_THRESHOLD = "/dev/memcg/memory.zram_critical_threshold"; +#include "memorycommon.h" namespace OHOS { bool ZramCriticalThresholdFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(ZRAM_CRITICAL_THRESHOLD, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", ZRAM_CRITICAL_THRESHOLD); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *zram_critical_threshold = "/dev/memcg/memory.zram_critical_threshold"; + bool ret = MemoryFuzzTest(data, size, zram_critical_threshold); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/zramwmratio_fuzzer/BUILD.gn b/test/fuzztest/memory/zramwmratio_fuzzer/BUILD.gn index 981da105b3d43a366245c67ef31f57c9d964a323..57d902f1b223e7b1e505ab70d43fea0293e03161 100644 --- a/test/fuzztest/memory/zramwmratio_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/zramwmratio_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("ZramWmRatioFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/zramwmratio_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "zramwmratio_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "zramwmratio_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/zramwmratio_fuzzer/zramwmratio_fuzzer.cpp b/test/fuzztest/memory/zramwmratio_fuzzer/zramwmratio_fuzzer.cpp index 35600058767c532a9779a4e7e8e5d994064826bc..8bd4d1749a25b82fa985e5407dfae16caf1709fc 100644 --- a/test/fuzztest/memory/zramwmratio_fuzzer/zramwmratio_fuzzer.cpp +++ b/test/fuzztest/memory/zramwmratio_fuzzer/zramwmratio_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *ZRAM_WR_RATIO = "/dev/memcg/memory.zram_wm_ratio"; +#include "memorycommon.h" namespace OHOS { bool ZramWmRatioFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(ZRAM_WR_RATIO, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", ZRAM_WR_RATIO); - close(fd); - return false; - } - - ret = write(fd, data, sizeof(uint8_t)); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *zram_wr_ratio = "/dev/memcg/memory.zram_wm_ratio"; + bool ret = MemoryFuzzTest(data, size, zram_wr_ratio); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/BUILD.gn b/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/BUILD.gn index 93a7875aa1ce71935c0e73a53a2b0f85f59c0005..3b2427242f5161e9d141cd30fec3bfd4e0627b3f 100644 --- a/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("ZswapdMaxReclaimSizeFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "zswapdmaxreclaimsize_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "zswapdmaxreclaimsize_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/zswapdmaxreclaimsize_fuzzer.cpp b/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/zswapdmaxreclaimsize_fuzzer.cpp index 6697c5c93cfd69c7e3153c521d6d4101967109df..2c43294b080830148a046eebd2e43d570bb121ec 100644 --- a/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/zswapdmaxreclaimsize_fuzzer.cpp +++ b/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/zswapdmaxreclaimsize_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *ZSWAPD_MAX_RECLAIM_SIZE = "/dev/memcg/memory.zswapd_max_reclaim_size"; +#include "memorycommon.h" namespace OHOS { bool ZswapdMaxReclaimSizeFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(ZSWAPD_MAX_RECLAIM_SIZE, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", ZSWAPD_MAX_RECLAIM_SIZE); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *zswapd_max_reclaim_size = "/dev/memcg/memory.zswapd_max_reclaim_size"; + bool ret = MemoryFuzzTest(data, size, zswapd_max_reclaim_size); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/zswapdmemcgsparam_fuzzer/BUILD.gn b/test/fuzztest/memory/zswapdmemcgsparam_fuzzer/BUILD.gn index 64fd1c4c730ee26b660ae00fe612e8beee2168cc..4416b1a0a96a0d260ee910a63f3f4105f32b6c2d 100644 --- a/test/fuzztest/memory/zswapdmemcgsparam_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/zswapdmemcgsparam_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("ZswapdMemcgsparamFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/zswapdmemcgsparam_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "zswapdmemcgsparam_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "zswapdmemcgsparam_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/zswapdmemcgsparam_fuzzer/zswapdmemcgsparam_fuzzer.cpp b/test/fuzztest/memory/zswapdmemcgsparam_fuzzer/zswapdmemcgsparam_fuzzer.cpp index 7b3577480260d9e1a0aa306e18e5f4720197b3de..b6820c08ded5a7415532509db6800e7712a0731d 100644 --- a/test/fuzztest/memory/zswapdmemcgsparam_fuzzer/zswapdmemcgsparam_fuzzer.cpp +++ b/test/fuzztest/memory/zswapdmemcgsparam_fuzzer/zswapdmemcgsparam_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *ZSWAPD_MEMCGS_PARAM = "/dev/memcg/memory.zswapd_memcgs_param"; +#include "memorycommon.h" namespace OHOS { bool ZswapdMemcgsParamFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(ZSWAPD_MEMCGS_PARAM, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", ZSWAPD_MEMCGS_PARAM); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *zswapd_memcgs_param = "/dev/memcg/memory.zswapd_memcgs_param"; + bool ret = MemoryFuzzTest(data, size, zswapd_memcgs_param); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/zswapdpressureshow_fuzzer/BUILD.gn b/test/fuzztest/memory/zswapdpressureshow_fuzzer/BUILD.gn index c12a1bbbac63a949e00f7792df8b9955094b7952..662852134d29e97f51ac7d02444bfa9c3655a15e 100644 --- a/test/fuzztest/memory/zswapdpressureshow_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/zswapdpressureshow_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("ZswapdPressureShowFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/zswapdpressureshow_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "zswapdpressureshow_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "zswapdpressureshow_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/zswapdpressureshow_fuzzer/zswapdpressureshow_fuzzer.cpp b/test/fuzztest/memory/zswapdpressureshow_fuzzer/zswapdpressureshow_fuzzer.cpp index 8dfcd24af3c36b43a7f9eb3653e30064f4624fbd..c6d423ea7d7e97fdbbea952b5ed8578095a800ad 100644 --- a/test/fuzztest/memory/zswapdpressureshow_fuzzer/zswapdpressureshow_fuzzer.cpp +++ b/test/fuzztest/memory/zswapdpressureshow_fuzzer/zswapdpressureshow_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *ZSWAPD_PRESSURE_SHOW = "/dev/memcg/memory.zswapd_pressure_show"; +#include "memorycommon.h" namespace OHOS { bool ZswapdPressureShowFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(ZSWAPD_PRESSURE_SHOW, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", ZSWAPD_PRESSURE_SHOW); - close(fd); - return false; - } - - ret = write(fd, data, sizeof(uint8_t)); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *zswapd_pressure_show = "/dev/memcg/memory.zswapd_pressure_show"; + bool ret = MemoryFuzzTest(data, size, zswapd_pressure_show); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/BUILD.gn b/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/BUILD.gn index 6a8459e72d23f312664f5400822fa2b5eb247ecd..9dd6656db70dc9b766ec086114896748df3cad96 100644 --- a/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/BUILD.gn +++ b/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/BUILD.gn @@ -21,13 +21,18 @@ ohos_fuzztest("ZswapdSingleMemcgParamFuzzTest") { fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer" + include_dirs = [ "../include" ] + cflags = [ "-g", "-O0", "-Wno-unused-variable", "-fno-omit-frame-pointer", ] - sources = [ "zswapdsinglememcgparam_fuzzer.cpp" ] + sources = [ + "../src/memorycommon.cpp", + "zswapdsinglememcgparam_fuzzer.cpp", + ] } group("fuzztest") { diff --git a/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/zswapdsinglememcgparam_fuzzer.cpp b/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/zswapdsinglememcgparam_fuzzer.cpp index 8e7c735f4da1260225d09647744d7c5733d17798..4966fa15b150a59599184248b7351380b619ccfa 100644 --- a/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/zswapdsinglememcgparam_fuzzer.cpp +++ b/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/zswapdsinglememcgparam_fuzzer.cpp @@ -15,39 +15,14 @@ #include #include -#include -#include -#include -#include -#include - -const char *ZSWAPD_SINGLE_MEMCG_PARAM = "/dev/memcg/memory.zswapd_single_memcg_param"; +#include "memorycommon.h" namespace OHOS { bool ZswapdSingleMemcgParamFuzzer(const uint8_t *data, size_t size) { - uint32_t value = 0; - - int fd = open(ZSWAPD_SINGLE_MEMCG_PARAM, O_RDWR); - if (fd < 0) { - return false; - } - - int ret = read(fd, &value, sizeof(value)); - if (ret < 0) { - printf("%s read fail\n", ZSWAPD_SINGLE_MEMCG_PARAM); - close(fd); - return false; - } - - ret = write(fd, data, size); - if (ret < 0) { - close(fd); - return false; - } - - close(fd); - return true; + const char *zswapd_single_memcg_param = "/dev/memcg/memory.zswapd_single_memcg_param"; + bool ret = MemoryFuzzTest(data, size, zswapd_single_memcg_param); + return ret; } } // namespace OHOS diff --git a/test/fuzztest/sched/addthreadtortg_fuzzer/addthreadtortg_fuzzer.cpp b/test/fuzztest/sched/addthreadtortg_fuzzer/addthreadtortg_fuzzer.cpp index 221d1d9d82f683b42f1fadc16e04565b4d5ab87b..edefad3cb4c570f6ffecd992bbde4b3f19a67916 100644 --- a/test/fuzztest/sched/addthreadtortg_fuzzer/addthreadtortg_fuzzer.cpp +++ b/test/fuzztest/sched/addthreadtortg_fuzzer/addthreadtortg_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "rtg_interface.h" using namespace std; diff --git a/test/fuzztest/sched/beginframefreq_fuzzer/beginframefreq_fuzzer.cpp b/test/fuzztest/sched/beginframefreq_fuzzer/beginframefreq_fuzzer.cpp index 0c617e5fc6469865716ba7ee85c18b82ec64e4a4..bf0f9d68a8ad35abe5b8372a74f2d8784a315da8 100644 --- a/test/fuzztest/sched/beginframefreq_fuzzer/beginframefreq_fuzzer.cpp +++ b/test/fuzztest/sched/beginframefreq_fuzzer/beginframefreq_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "rtg_interface.h" using namespace std; @@ -22,14 +25,14 @@ namespace OHOS { bool BeginFrameFreqFuzzTest(const uint8_t *data, size_t size) { bool ret = false; - constexpr int MARGIN_UPPER_LIMIT_TIME = 32000; - constexpr int MARGIN_LOWER_LIMIT_TIME = -32000; + constexpr int margin_upper_limit_time = 32000; + constexpr int margin_lower_limit_time = -32000; if (data == nullptr) { return ret; } else { uint8_t *countData = const_cast(data); int margin = *(reinterpret_cast(countData)); - if (margin < MARGIN_LOWER_LIMIT_TIME || margin > MARGIN_UPPER_LIMIT_TIME) { + if (margin < margin_lower_limit_time || margin > margin_upper_limit_time) { return ret; } int grpId = 2; diff --git a/test/fuzztest/sched/endframefreq_fuzzer/endframefreq_fuzzer.cpp b/test/fuzztest/sched/endframefreq_fuzzer/endframefreq_fuzzer.cpp index 70fcd22731d75afcb1ccc02ff1f2095795ec5f78..d7cd0440a277773219c9d3d9ed7fbb4e7a701263 100644 --- a/test/fuzztest/sched/endframefreq_fuzzer/endframefreq_fuzzer.cpp +++ b/test/fuzztest/sched/endframefreq_fuzzer/endframefreq_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "rtg_interface.h" using namespace std; diff --git a/test/fuzztest/sched/endscene_fuzzer/endscene_fuzzer.cpp b/test/fuzztest/sched/endscene_fuzzer/endscene_fuzzer.cpp index bda65aeb7db3a324ca869804aac3954e31dc4f8f..cb309a5e7f803671ff01dd9274fa781c2bdb8764 100644 --- a/test/fuzztest/sched/endscene_fuzzer/endscene_fuzzer.cpp +++ b/test/fuzztest/sched/endscene_fuzzer/endscene_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "rtg_interface.h" using namespace std; diff --git a/test/fuzztest/sched/searchrtgfortid_fuzzer/searchrtgfortid_fuzzer.cpp b/test/fuzztest/sched/searchrtgfortid_fuzzer/searchrtgfortid_fuzzer.cpp index d5bba73a19d8a1d6f039f7e0e7710429d0e9a406..8d773434808636dba29ec2c65eea3b1ab7e36e45 100644 --- a/test/fuzztest/sched/searchrtgfortid_fuzzer/searchrtgfortid_fuzzer.cpp +++ b/test/fuzztest/sched/searchrtgfortid_fuzzer/searchrtgfortid_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "rtg_interface.h" using namespace std; diff --git a/test/fuzztest/sched/setmargin_fuzzer/setmargin_fuzzer.cpp b/test/fuzztest/sched/setmargin_fuzzer/setmargin_fuzzer.cpp index 92209c911c3658a5426993727e09614572f5b10b..ceddac4043dc0c9c76afbe1b4c39ac24257241ce 100644 --- a/test/fuzztest/sched/setmargin_fuzzer/setmargin_fuzzer.cpp +++ b/test/fuzztest/sched/setmargin_fuzzer/setmargin_fuzzer.cpp @@ -14,6 +14,9 @@ */ #include +#include +#include +#include "__config" #include "rtg_interface.h" using namespace std; @@ -22,14 +25,14 @@ namespace OHOS { bool SetMarginFuzzTest(const uint8_t *data, size_t size) { bool ret = false; - constexpr int MARGIN_UPPER_LIMIT_TIME = 32000; - constexpr int MARGIN_LOWER_LIMIT_TIME = -32000; + constexpr int margin_upper_limit_time = 32000; + constexpr int margin_lower_limit_time = -32000; if (data == nullptr) { return ret; } else { uint8_t *countData = const_cast(data); int margin = *(reinterpret_cast(countData)); - if (margin < MARGIN_LOWER_LIMIT_TIME || margin > MARGIN_UPPER_LIMIT_TIME) { + if (margin < margin_lower_limit_time || margin > margin_upper_limit_time) { return ret; } int grpId = 2;