be/src/common/cgroup_memory_ctl.cpp

// 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