cgroups-config.hpp

Go to the documentation of this file.

/*
 *  Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
 *
 *  Contact: Dariusz Michaluk <d.michaluk@samsung.com>
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License
 */

#ifndef CGROUPS_CONFIG_HPP
#define CGROUPS_CONFIG_HPP

#include "config.hpp"
#include "cargo/fields.hpp"

#include <string>
#include <vector>

namespace vasum {

struct CGroupMemoryConfig {

    uint64_t limit;

    uint64_t reservation;

    uint64_t swap;

    uint64_t kernel;

    uint64_t swappiness;

    CARGO_REGISTER
    (
        limit,
        reservation,
        swap,
        kernel,
        swappiness
    )
};

struct CGroupCpuConfig {

    uint64_t shares;

    uint64_t quota;

    uint64_t period;

    uint64_t realtimeRuntime;

    uint64_t realtimePeriod;

    std::string cpus;

    std::string mems;

    CARGO_REGISTER
    (
        shares,
        quota,
        period,
        realtimeRuntime,
        realtimePeriod,
        cpus,
        mems
    )
};

struct CGroupPidsConfig {

    int64_t limit;

    CARGO_REGISTER
    (
        limit
    )
};

struct WeightDevice {

    int64_t major;
    int64_t minor;

    uint16_t weight;

    uint16_t leafWeight;

    CARGO_REGISTER
    (
        major,
        minor,
        weight,
        leafWeight
    )
};

struct ThrottleDevice {

    int64_t major;
    int64_t minor;

    uint64_t rate;

    CARGO_REGISTER
    (
        major,
        minor,
        rate
    )
};

struct CGroupBlockIOConfig {

    uint16_t blkioWeight;

    uint16_t blkioLeafWeight;

    std::vector<WeightDevice> blkioWeightDevice;

    std::vector<ThrottleDevice> blkioThrottleWriteBpsDevice;
    std::vector<ThrottleDevice> blkioThrottleReadBpsDevice;
    std::vector<ThrottleDevice> blkioThrottleWriteIOPSDevice;
    std::vector<ThrottleDevice> blkioThrottleReadIOPSDevice;

    CARGO_REGISTER
    (
        blkioWeight,
        blkioLeafWeight,
        blkioWeightDevice,
        blkioThrottleWriteBpsDevice,
        blkioThrottleReadBpsDevice,
        blkioThrottleWriteIOPSDevice,
        blkioThrottleReadIOPSDevice
    )
};

struct HugePageLimit {

    std::string pageSize;

    uint64_t limit;

    CARGO_REGISTER
    (
        pageSize,
        limit
    )
};

typedef std::vector<HugePageLimit> CGroupHugePageLimitsConfig;

struct Priority {

    std::string name;

    uint32_t priority;

    CARGO_REGISTER
    (
        name,
        priority
    )
};

struct CGroupNetworkConfig {

    std::string classID;

    std::vector<Priority> priorities;

    CARGO_REGISTER
    (
        classID,
        priorities
    )
};

} // namespace vasum


#endif // CGROUPS_CONFIG_HPP