add memory dufuzz testcases.

Signed-off-by: 13359001024 <wenfei9@huawei.com>

test/fuzztest/BUILD.gn

@@ -18,6 +18,7 @@ group("fuzztest") {
   deps += [
     "accesstokenid:fuzztest",
     "hc_node:fuzztest",
+    "memory:fuzztest",
     "sched:fuzztest",
   ]
 }

test/fuzztest/memory/BUILD.gn

@@ -0,0 +1,38 @@
+# 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.
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+
+  deps += [
+    "anonrefaultsnapshotmininterval_fuzzer:AnonRefaultSnapshotMinIntervalFuzzTest",
+    "appscore_fuzzer:AppScoreFuzzTest",
+    "areaanonrefaultthreshold_fuzzer:AreaAnonRefaultThresholdFuzzTest",
+    "availbuffers_fuzzer:AvailBuffersFuzzTest",
+    "bufferratioparams_fuzzer:BufferRatioParamsFuzzTest",
+    "compressratio_fuzzer:CompressRatioFuzzTest",
+    "emptyroundcheckthreshold_fuzzer:EmptyRoundCheckThresholdFuzzTest",
+    "emptyroundskipinterval_fuzzer:EmptyRoundSkipIntervalFuzzTest",
+    "forceshrinkanon_fuzzer:ForceShrinkAnonFuzzTest",
+    "maxskipinterval_fuzzer:MaxSkipIntervalFuzzTest",
+    "name_fuzzer:NameFuzzTest",
+    "ubufs2zramratio_fuzzer:UbUfs2zramRatioFuzzTest",
+    "zramcriticalthreshold_fuzzer:ZramCriticalThresholdFuzzTest",
+    "zramwmratio_fuzzer:ZramWmRatioFuzzTest",
+    "zswapdmaxreclaimsize_fuzzer:ZswapdMaxReclaimSizeFuzzTest",
+    "zswapdmemcgsparam_fuzzer:ZswapdMemcgsparamFuzzTest",
+    "zswapdpressureshow_fuzzer:ZswapdPressureShowFuzzTest",
+    "zswapdsinglememcgparam_fuzzer:ZswapdSingleMemcgParamFuzzTest",
+  ]
+}

test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/BUILD.gn

@@ -0,0 +1,36 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("AnonRefaultSnapshotMinIntervalFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "anonrefaultsnapshotmininterval_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":AnonRefaultSnapshotMinIntervalFuzzTest" ]
+}

test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/anonrefaultsnapshotmininterval_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *ANON_REFAULT_SNAPSHOT_MIN_INTERVAL = "/dev/memcg/memory.anon_refault_snapshot_min_interval";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::AnonRefaultSnapshotMinIntervalFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/anonrefaultsnapshotmininterval_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/appscore_fuzzer/BUILD.gn

@@ -0,0 +1,36 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("AppScoreFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/appscore_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "appscore_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":AppScoreFuzzTest" ]
+}

test/fuzztest/memory/appscore_fuzzer/appscore_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *APP_SCORE = "/dev/memcg/memory.app_score";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::AppScoreFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/appscore_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/appscore_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/BUILD.gn

@@ -0,0 +1,36 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("AreaAnonRefaultThresholdFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/areaanonrefaultthreshold_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "areaanonrefaultthreshold_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":AreaAnonRefaultThresholdFuzzTest" ]
+}

test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/areaanonrefaultthreshold_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *AREA_ANON_REFAULT_THRESHOLD = "/dev/memcg/memory.area_anon_refault_threshold";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::AreaAnonRefaultThresholdFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/areaanonrefaultthreshold_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/availbuffers_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("AvailBuffersFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/availbuffers_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "availbuffers_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":AvailBuffersFuzzTest" ]
+}

test/fuzztest/memory/availbuffers_fuzzer/availbuffers_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *AVAIL_BUFFERS = "/dev/memcg/memory.avail_buffers";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::AvailBuffersFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/availbuffers_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/availbuffers_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/bufferratioparams_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("BufferRatioParamsFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/bufferratioparams_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "bufferratioparams_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":BufferRatioParamsFuzzTest" ]
+}

test/fuzztest/memory/bufferratioparams_fuzzer/bufferratioparams_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *BUFFER_RATIO_PARAMS = "/dev/memcg/memory.buffer_ratio_params";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::BufferRatioParamsFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/bufferratioparams_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/bufferratioparams_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/compressratio_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("CompressRatioFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/compressratio_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "compressratio_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":CompressRatioFuzzTest" ]
+}

test/fuzztest/memory/compressratio_fuzzer/compressratio_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *COMPRESS_RATIO = "/dev/memcg/memory.compress_ratio";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::CompressRatioFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/compressratio_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/compressratio_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/BUILD.gn

@@ -0,0 +1,36 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("EmptyRoundCheckThresholdFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/emptyroundcheckthreshold_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "emptyroundcheckthreshold_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":EmptyRoundCheckThresholdFuzzTest" ]
+}

test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/emptyroundcheckthreshold_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *EMPTY_ROUND_CHECK_THRESHOLD = "/dev/memcg/memory.empty_round_check_threshold";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::EmptyRoundCheckThresholdFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/emptyroundcheckthreshold_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/emptyroundskipinterval_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("EmptyRoundSkipIntervalFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/emptyroundskipinterval_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "emptyroundskipinterval_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":EmptyRoundSkipIntervalFuzzTest" ]
+}

test/fuzztest/memory/emptyroundskipinterval_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/emptyroundskipinterval_fuzzer/emptyroundskipinterval_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *EMPTY_ROUND_SKIP_INTERVAL = "/dev/memcg/memory.empty_round_skip_interval";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::EmptyRoundSkipIntervalFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/emptyroundskipinterval_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/forceshrinkanon_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("ForceShrinkAnonFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/forceshrinkanon_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "forceshrinkanon_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":ForceShrinkAnonFuzzTest" ]
+}

test/fuzztest/memory/forceshrinkanon_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/forceshrinkanon_fuzzer/forceshrinkanon_fuzzer.cpp

@@ -0,0 +1,50 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *FORCE_SHRINK_ANON = "/dev/memcg/memory.force_shrink_anon";
+
+namespace OHOS {
+bool ForceShrinkAnonFuzzer(const uint8_t *data, size_t size)
+{
+    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);
+        close(fd);
+        return false;
+    }
+
+    close(fd);
+    return true;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::ForceShrinkAnonFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/forceshrinkanon_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/maxskipinterval_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("MaxSkipIntervalFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/maxskipinterval_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "maxskipinterval_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":MaxSkipIntervalFuzzTest" ]
+}

test/fuzztest/memory/maxskipinterval_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/maxskipinterval_fuzzer/maxskipinterval_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *MAX_SKIP_INTERVAL = "/dev/memcg/memory.max_skip_interval";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::MaxSkipIntervalFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/maxskipinterval_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/name_fuzzer/BUILD.gn

@@ -0,0 +1,36 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("NameFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file = "//kernel/linux/build/test/fuzztest/memory/name_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "name_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":NameFuzzTest" ]
+}

test/fuzztest/memory/name_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/name_fuzzer/name_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *NAME = "/dev/memcg/memory.name";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::NameFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/name_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/ubufs2zramratio_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("UbUfs2zramRatioFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/ubufs2zramratio_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "ubufs2zramratio_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":UbUfs2zramRatioFuzzTest" ]
+}

test/fuzztest/memory/ubufs2zramratio_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/ubufs2zramratio_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/ubufs2zramratio_fuzzer/ubufs2zramratio_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *UB_UFS2ZRAM_RATIO = "/dev/memcg/memory.ub_ufs2zram_ratio";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::UbUfs2zramRatioFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/zramcriticalthreshold_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("ZramCriticalThresholdFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/zramcriticalthreshold_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "zramcriticalthreshold_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":ZramCriticalThresholdFuzzTest" ]
+}

test/fuzztest/memory/zramcriticalthreshold_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/zramcriticalthreshold_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/zramcriticalthreshold_fuzzer/zramcriticalthreshold_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *ZRAM_CRITICAL_THRESHOLD = "/dev/memcg/memory.zram_critical_threshold";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::ZramCriticalThresholdFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/zramwmratio_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("ZramWmRatioFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/zramwmratio_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "zramwmratio_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":ZramWmRatioFuzzTest" ]
+}

test/fuzztest/memory/zramwmratio_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/zramwmratio_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/zramwmratio_fuzzer/zramwmratio_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *ZRAM_WR_RATIO = "/dev/memcg/memory.zram_wm_ratio";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::ZramWmRatioFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("ZswapdMaxReclaimSizeFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "zswapdmaxreclaimsize_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":ZswapdMaxReclaimSizeFuzzTest" ]
+}

test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/zswapdmaxreclaimsize_fuzzer/zswapdmaxreclaimsize_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *ZSWAPD_MAX_RECLAIM_SIZE = "/dev/memcg/memory.zswapd_max_reclaim_size";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::ZswapdMaxReclaimSizeFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/zswapdmemcgsparam_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("ZswapdMemcgsparamFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/zswapdmemcgsparam_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "zswapdmemcgsparam_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":ZswapdMemcgsparamFuzzTest" ]
+}

test/fuzztest/memory/zswapdmemcgsparam_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/zswapdmemcgsparam_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/zswapdmemcgsparam_fuzzer/zswapdmemcgsparam_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *ZSWAPD_MEMCGS_PARAM = "/dev/memcg/memory.zswapd_memcgs_param";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::ZswapdMemcgsParamFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/zswapdpressureshow_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("ZswapdPressureShowFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/zswapdpressureshow_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "zswapdpressureshow_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":ZswapdPressureShowFuzzTest" ]
+}

test/fuzztest/memory/zswapdpressureshow_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/zswapdpressureshow_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/zswapdpressureshow_fuzzer/zswapdpressureshow_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *ZSWAPD_PRESSURE_SHOW = "/dev/memcg/memory.zswapd_pressure_show";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::ZswapdPressureShowFuzzer(data, size);
+    return 0;
+}

test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/BUILD.gn

@@ -0,0 +1,37 @@
+# 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.
+
+import("//build/config/features.gni")
+import("//build/test.gni")
+
+module_output_path = "linuxkerneltest/memory"
+
+ohos_fuzztest("ZswapdSingleMemcgParamFuzzTest") {
+  module_out_path = module_output_path
+  fuzz_config_file =
+      "//kernel/linux/build/test/fuzztest/memory/zswapdsinglememcgparam_fuzzer"
+
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+  ]
+  sources = [ "zswapdsinglememcgparam_fuzzer.cpp" ]
+}
+
+group("fuzztest") {
+  testonly = true
+  deps = []
+  deps += [ ":ZswapdSingleMemcgParamFuzzTest" ]
+}

test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/corpus/init

@@ -0,0 +1,13 @@
+# Copyright (c) 2020-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.
+FUZZ

test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

test/fuzztest/memory/zswapdsinglememcgparam_fuzzer/zswapdsinglememcgparam_fuzzer.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstdio>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+const char *ZSWAPD_SINGLE_MEMCG_PARAM = "/dev/memcg/memory.zswapd_single_memcg_param";
+
+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;
+}
+} // namespace OHOS
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+    OHOS::ZswapdSingleMemcgParamFuzzer(data, size);
+    return 0;
+}