// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements. See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership. The ASF licenses this file

// to you 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.

// This file is copied from

// https://github.com/ClickHouse/ClickHouse/blob/master/src/Common/CgroupsMemoryUsageObserver.cpp

// and modified by Doris

#include "common/cgroup_memory_ctl.h"

#include <filesystem>

#include <fstream>

#include <memory>

#include <utility>

#include "common/status.h"

#include "util/cgroup_util.h"

#include "util/error_util.h"

namespace doris {

// Is the memory controller of cgroups v2 enabled on the system?

// Assumes that cgroupsv2_enable() is enabled.

Status cgroupsv2_memory_controller_enabled(bool* ret) {

#if defined(OS_LINUX)

if (!CGroupUtil::cgroupsv2_enable()) {

return Status::CgroupError("cgroupsv2_enable is false");

}

// According to https://docs.kernel.org/admin-guide/cgroup-v2.html, file "cgroup.controllers" defines which controllers are available

// for the current + child cgroups. The set of available controllers can be restricted from level to level using file

// "cgroups.subtree_control". It is therefore sufficient to check the bottom-most nested "cgroup.controllers" file.

std::string cgroup = CGroupUtil::cgroupv2_of_process();

auto cgroup_dir = cgroup.empty() ? default_cgroups_mount : (default_cgroups_mount / cgroup);

std::ifstream controllers_file(cgroup_dir / "cgroup.controllers");

if (!controllers_file.is_open()) {

*ret = false;

return Status::CgroupError("open cgroup.controllers failed");

}

std::string controllers;

std::getline(controllers_file, controllers);

*ret = controllers.find("memory") != std::string::npos;

return Status::OK();

#else

*ret = false;

return Status::CgroupError("cgroupsv2 only support Linux");

#endif

}

struct CgroupsV1Reader : CGroupMemoryCtl::ICgroupsReader {

explicit CgroupsV1Reader(std::filesystem::path mount_file_dir)

: _mount_file_dir(std::move(mount_file_dir)) {}

Status read_memory_limit(int64_t* value) override {

RETURN_IF_ERROR(CGroupUtil::read_int_line_from_cgroup_file(

(_mount_file_dir / "memory.limit_in_bytes"), value));

return Status::OK();

}

Status read_memory_usage(int64_t* value) override {

std::unordered_map<std::string, int64_t> metrics_map;

CGroupUtil::read_int_metric_from_cgroup_file((_mount_file_dir / "memory.stat"),

metrics_map);

*value = metrics_map["rss"];

return Status::OK();

}

private:

std::filesystem::path _mount_file_dir;

};

struct CgroupsV2Reader : CGroupMemoryCtl::ICgroupsReader {

explicit CgroupsV2Reader(std::filesystem::path mount_file_dir)

: _mount_file_dir(std::move(mount_file_dir)) {}

Status read_memory_limit(int64_t* value) override {

std::filesystem::path file_path = _mount_file_dir / "memory.max";

std::string line;

std::ifstream file_stream(file_path, std::ios::in);

getline(file_stream, line);

if (file_stream.fail() || file_stream.bad()) {

return Status::CgroupError("Error reading {}: {}", file_path.string(),

get_str_err_msg());

}

// This means no limit, for example, all process in linux will belong to a cgroup, and

// the default value of the memory limit in memory.max file is "max", which means no limit.

if (line == "max") {

*value = std::numeric_limits<int64_t>::max();

return Status::OK();

}

RETURN_IF_ERROR(CGroupUtil::read_int_line_from_cgroup_file(file_path, value));

return Status::OK();

}

Status read_memory_usage(int64_t* value) override {

RETURN_IF_ERROR(CGroupUtil::read_int_line_from_cgroup_file(

(_mount_file_dir / "memory.current"), value));

std::unordered_map<std::string, int64_t> metrics_map;

CGroupUtil::read_int_metric_from_cgroup_file((_mount_file_dir / "memory.stat"),

metrics_map);

int64_t inactive_file =

metrics_map.contains("inactive_file") ? metrics_map["inactive_file"] : 0;

int64_t active_file = metrics_map.contains("active_file") ? metrics_map["active_file"] : 0;

int64_t slab_reclaimable =

metrics_map.contains("slab_reclaimable") ? metrics_map["slab_reclaimable"] : 0;

if (inactive_file < 0 || active_file < 0 || slab_reclaimable < 0) {

// In this scenario, not return error, ignore it and print log.

LOG(WARNING) << "CgroupsV2Reader read_memory_usage missing expected metrics in "

"memory.stat, inactive_file: "

<< inactive_file << ", active_file: " << active_file

<< ", slab_reclaimable: " << slab_reclaimable;

return Status::OK();

}

const int64_t reclaimable_usage = inactive_file + active_file + slab_reclaimable;

if (*value < reclaimable_usage) {

LOG(WARNING)

<< "CgroupsV2Reader read_memory_usage negative memory usage, not - reclaimable "

"usage any more, just return memory.current: "

<< *value << ", inactive_file: " << inactive_file

<< ", active_file: " << active_file

<< ", slab_reclaimable: " << slab_reclaimable;

// In this case, do not return an error, just ignore the negative usage and continue.

// If return error, the upper system will use os available memory instead of cgroup available memory, which may cause OOM more easily.

return Status::OK();

}

// The reclaimable file cache described here should not be counted as used memory:

// https://github.com/ClickHouse/ClickHouse/issues/64652#issuecomment-2149630667

// Part of "slab" that might be reclaimed, such as dentries and inodes.

// https://arthurchiao.art/blog/cgroupv2-zh/

*value -= reclaimable_usage;

return Status::OK();

}

private:

std::filesystem::path _mount_file_dir;

};

std::pair<std::string, CGroupUtil::CgroupsVersion> get_cgroups_path() {

bool enable_controller;

auto cgroupsv2_memory_controller_st = cgroupsv2_memory_controller_enabled(&enable_controller);

if (CGroupUtil::cgroupsv2_enable() && cgroupsv2_memory_controller_st.ok() &&

enable_controller) {

auto v2_memory_stat_path = CGroupUtil::get_cgroupsv2_path("memory.stat");

auto v2_memory_current_path = CGroupUtil::get_cgroupsv2_path("memory.current");

auto v2_memory_max_path = CGroupUtil::get_cgroupsv2_path("memory.max");

if (v2_memory_stat_path.has_value() && v2_memory_current_path.has_value() &&

v2_memory_max_path.has_value() && v2_memory_stat_path == v2_memory_current_path &&

v2_memory_current_path == v2_memory_max_path) {

return {*v2_memory_stat_path, CGroupUtil::CgroupsVersion::V2};

}

}

std::string cgroup_path;

auto st = CGroupUtil::find_abs_cgroupv1_path("memory", &cgroup_path);

if (st.ok()) {

return {cgroup_path, CGroupUtil::CgroupsVersion::V1};

}

return {"", CGroupUtil::CgroupsVersion::V1};

}

Status get_cgroups_reader(std::shared_ptr<CGroupMemoryCtl::ICgroupsReader>& reader) {

const auto [cgroup_path, version] = get_cgroups_path();

if (cgroup_path.empty()) {

bool enable_controller;

auto st = cgroupsv2_memory_controller_enabled(&enable_controller);

return Status::CgroupError(

"Cannot find cgroups v1 or v2 current memory file, cgroupsv2_enable: {},{}, "

"cgroupsv2_memory_controller_enabled: {}, cgroupsv1_enable: {}",

CGroupUtil::cgroupsv2_enable(), enable_controller, st.to_string(),

CGroupUtil::cgroupsv1_enable());

}

if (version == CGroupUtil::CgroupsVersion::V2) {

reader = std::make_shared<CgroupsV2Reader>(cgroup_path);

} else {

reader = std::make_shared<CgroupsV1Reader>(cgroup_path);

}

return Status::OK();

}

Status CGroupMemoryCtl::find_cgroup_mem_limit(int64_t* bytes) {

std::shared_ptr<CGroupMemoryCtl::ICgroupsReader> reader;

RETURN_IF_ERROR(get_cgroups_reader(reader));

RETURN_IF_ERROR(reader->read_memory_limit(bytes));

return Status::OK();

}

Status CGroupMemoryCtl::find_cgroup_mem_usage(int64_t* bytes) {

std::shared_ptr<CGroupMemoryCtl::ICgroupsReader> reader;

RETURN_IF_ERROR(get_cgroups_reader(reader));

RETURN_IF_ERROR(reader->read_memory_usage(bytes));

return Status::OK();

}

std::string CGroupMemoryCtl::debug_string() {

const auto [cgroup_path, version] = get_cgroups_path();

if (cgroup_path.empty()) {

bool enable_controller;

auto st = cgroupsv2_memory_controller_enabled(&enable_controller);

return fmt::format(

"Cannot find cgroups v1 or v2 current memory file, cgroupsv2_enable: {},{}, "

"cgroupsv2_memory_controller_enabled: {}, cgroupsv1_enable: {}",

CGroupUtil::cgroupsv2_enable(), enable_controller, st.to_string(),

CGroupUtil::cgroupsv1_enable());

}

int64_t mem_limit;

auto mem_limit_st = find_cgroup_mem_limit(&mem_limit);

int64_t mem_usage;

auto mem_usage_st = find_cgroup_mem_usage(&mem_usage);

return fmt::format(

"Process CGroup Memory Info (cgroups path: {}, cgroup version: {}): memory limit: "

"{}, "

"memory usage: {}",

cgroup_path, (version == CGroupUtil::CgroupsVersion::V1) ? "v1" : "v2",

mem_limit_st.ok() ? std::to_string(mem_limit) : mem_limit_st.to_string(),

mem_usage_st.ok() ? std::to_string(mem_usage) : mem_usage_st.to_string());

}

} // namespace doris