14937352646

Committed 09 May 2025 08:40PM UTC coverage: 54.044% (-2.1%) from 56.161%

Build # 14937352646

Build Type

push

github

Committed by

drakenclimber

Commit Message

wip - have it working

sudo ./src/tools/cgset -p -r AllowedCPUs=1-3,6-13,15 foo.scope

Signed-off-by: Tom Hromatka <tom.hromatka@oracle.com>

Run Details

8 of 222 new or added lines in 2 files covered. (3.6%)

170 existing lines in 13 files now uncovered.

5573 of 10312 relevant lines covered (54.04%)

325.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.37

/src/systemd.c

/* SPDX-License-Identifier: LGPL-2.1-only */
/**
 * Copyright (c) 2022-2025 Oracle and/or its affiliates.
 * Author: Tom Hromatka <tom.hromatka@oracle.com>
 * Author: Silvia Chapa <silvia.chapa@oracle.com>
 */

#include "libcgroup-internal.h"

#ifdef WITH_SYSTEMD
#include <systemd/sd-bus.h>
#include <libcgroup.h>
#include <unistd.h>
#include <assert.h>
#include <stdlib.h>
#include <libgen.h>
#include <errno.h>

#define USEC_PER_SEC 1000000

static const char * const modes[] = {
        "fail",                        /* CGROUP_SYSTEMD_MODE_FAIL */
        "replace",                /* CGROUP_SYSTEMD_MODE_REPLACE */
        "isolate",                /* CGROUP_SYSTEMD_MODE_ISOLATE */
        "ignore-dependencies",        /* CGROUP_SYSTEMD_MODE_IGNORE_DEPS */
        "ignore-requirements",        /* CGROUP_SYSTEMD_MODE_IGNORE_REQS */
};
static_assert(ARRAY_SIZE(modes) == CGROUP_SYSTEMD_MODE_CNT,
              "modes[] array must be same length as CGROUP_SYSTEMD_MODE_CNT");

/*
 * controller_name table borrowed from:
 * https://github.com/systemd/systemd/blob/main/src/basic/cgroup-util.c#L2260
 */
static const char * const controller_name[] = {
        /* subset of controllers (cgroup v1/v2), systemd supports */
        "cpu",
        "cpuacct",
        "cpuset",
        "io",
        "blkio",
        "memory",
        "devices",
        "pids",

        /* systemd pseudo BPF based controllers (cgroup v2 ) */
        "bpf-firewall",
        "bpf-devices",
        "bpf-foreign",
        "bpf-socket-bind",
        "bpf-restrict-network-interfaces",
};

static const char * const sender = "org.freedesktop.systemd1";
static const char * const path = "/org/freedesktop/systemd1";
static const char * const interface = "org.freedesktop.systemd1.Manager";

const struct systemd_property_and_type systemd_property_table[] = {
        { "AllowedCPUs", SD_BUS_TYPE_ARRAY, SD_BUS_TYPE_BYTE },
        { "CPUAccounting", SD_BUS_TYPE_BOOLEAN, _SD_BUS_TYPE_INVALID },
        { "CPUQuotaPeriodUSec", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "CPUQuotaPerSecUSec", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "CPUWeight", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "DefaultMemoryLow", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "DefaultMemoryLowScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "DefaultMemoryMin", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "DefaultMemoryMinScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "DefaultStartupMemoryLow", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "IOAccounting", SD_BUS_TYPE_BOOLEAN, _SD_BUS_TYPE_INVALID },
        { "IOWeight", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryAccounting", SD_BUS_TYPE_BOOLEAN, _SD_BUS_TYPE_INVALID },
        { "MemoryHigh", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryHighScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryLow", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryLowScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryMax", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryMaxScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryMin", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryMinScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemorySwapMax", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemorySwapMaxScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryZSwapMax", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryZSwapMaxScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "MemoryZSwapWriteback", SD_BUS_TYPE_BOOLEAN, _SD_BUS_TYPE_INVALID },
        { "StartupAllowedCPUs", SD_BUS_TYPE_ARRAY, SD_BUS_TYPE_BYTE },
        { "StartupIOWeight", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "StartupMemoryLow", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "StartupMemoryHigh", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "StartupMemoryMax", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "StartupMemorySwapMax", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "StartupMemoryZSwapMax", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "TasksAccounting", SD_BUS_TYPE_BOOLEAN, _SD_BUS_TYPE_INVALID },
        { "TasksMax", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
        { "TasksMaxScale", SD_BUS_TYPE_UINT64, _SD_BUS_TYPE_INVALID },
};
const int systemd_property_table_sz = ARRAY_SIZE(systemd_property_table);

int cgroup_set_default_scope_opts(struct cgroup_systemd_scope_opts * const opts)
{
        if (!opts)
                return ECGINVAL;

        opts->delegated = 1;
        opts->mode = CGROUP_SYSTEMD_MODE_FAIL;
        opts->pid = -1;

        return 0;
}

/*
 * Returns time elapsed in usec
 *
 * Inspired-by: https://github.com/cockpit-project/cockpit/blob/main/src/tls/socket-io.c#L39
 */
static int64_t elapsed_time(const struct timespec * const start, const struct timespec * const end)
{
        int64_t elapsed = (end->tv_sec - start->tv_sec) * 1000000 +
                          (end->tv_nsec - start->tv_nsec) / 1000;

        assert(elapsed >= 0);

        return elapsed;
}

static int job_removed_callback(sd_bus_message *message, void *user_data, sd_bus_error *error)
{
        const char *result, *msg_path, *scope_name;
        const char **job_path = user_data;
        int ret;

        ret = sd_bus_message_read(message, "uoss", NULL, &msg_path, &scope_name, &result);
        if (ret < 0) {
                cgroup_err("callback message read failed: %d\n", errno);
                return 0;
        }

        if (*job_path == NULL || strcmp(msg_path, *job_path) != 0) {
                cgroup_dbg("Received a systemd signal, but it was not our message\n");
                return 0;
        }

        cgroup_dbg("Received JobRemoved signal for scope %s.  Result: %s\n", scope_name, result);

        /*
         * Use the job_path pointer as a way to inform the original thread that the job has
         * completed.
         */
        *job_path = NULL;
        return 0;
}

static int validate_scope_slice_name(const char * const scope_name, const char * const slice_name)
{
        char *_scope_name = NULL;
        int i, len, ret = 0;

        /* get the scope name without the suffix, min length is <n>.scope */
        len = strlen(scope_name) - 6;
        if (len < 1)
                cgroup_warn("Invalid scope name %s\n", scope_name);
        else if (strcmp(&scope_name[len], ".scope") != 0)
                cgroup_warn("scope doesn't have expected suffix\n");

        /* get the slice name without the suffix, min length is <n>.slice */
        len = strlen(slice_name) - 6;
        if (len < 1)
                cgroup_warn("Invalid slice name %s\n", slice_name);
        else if (strcmp(&slice_name[len], ".slice") != 0)
                cgroup_warn("slice doesn't have expected suffix\n");

        /*
         * systemd will silently prefix a '_' to the scope name and
         * create, and delegate it under the slice. If it matches with any
         * of the controller in the controller_name[]. i.e.,
         * oracle.slice/cpuset.scope, will be created as
         * oracle.slice/_cpuset.scope
         *
         * Disallow such scope names, that will cause confusion to the
         * users, where they might try to operate scope cgroup, but
         * the delegated scope is _scope cgroup.
         */
        _scope_name = strdup(scope_name);
        if (_scope_name == NULL) {
                cgroup_err("Failed to allocate memory for _scope_name\n");
                last_errno = errno;
                ret = 1;
                goto out;
        }

        len = strlen(_scope_name) - 6;        /* strlen(".scope") + '\0' */
        _scope_name[len] = '\0';

        for (i = 0; i < ARRAY_SIZE(controller_name); i++) {
                if (strcmp(_scope_name, controller_name[i]))
                        continue;

                cgroup_err("Invalid scope name, using controller name %s\n", controller_name[i]);
                ret = 1;
                break;
        }

        free(_scope_name);
out:
        return ret;
}

int cgroup_create_scope(const char * const scope_name, const char * const slice_name,
                        const struct cgroup_systemd_scope_opts * const opts)
{
        sd_bus_message *msg = NULL, *reply = NULL;
        int ret = 0, sdret = 0, cgret = ECGFAIL;
        sd_bus_error error = SD_BUS_ERROR_NULL;
        const char *job_path = NULL;
        struct timespec start, now;
        sd_bus *bus = NULL;
        pid_t child_pid;

        if (!scope_name || !slice_name || !opts)
                return ECGINVAL;

        if (validate_scope_slice_name(scope_name, slice_name))
                return ECGINVAL;

        if (opts->mode >= CGROUP_SYSTEMD_MODE_CNT) {
                cgroup_err("invalid systemd mode: %d\n", opts->mode);
                return ECGINVAL;
        }

        if (opts->mode == CGROUP_SYSTEMD_MODE_ISOLATE ||
            opts->mode == CGROUP_SYSTEMD_MODE_IGNORE_DEPS ||
            opts->mode == CGROUP_SYSTEMD_MODE_IGNORE_REQS) {
                cgroup_err("unsupported systemd mode: %d\n", opts->mode);
                return ECGINVAL;
        }

        if (opts->pid < 0) {
                child_pid = fork();
                if (child_pid < 0) {
                        last_errno = errno;
                        cgroup_err("fork failed: %d\n", errno);
                        return ECGOTHER;
                }

                if (child_pid == 0) {
                        static char * const args[] = {"libcgroup_systemd_idle_thread", NULL};

                        /*
                         * Have the child sleep forever.  Systemd will delete the scope if
                         * there isn't a running process in it.
                         */
                        execvp("libcgroup_systemd_idle_thread", args);

                        /* The child process should never get here */
                        last_errno = errno;
                        cgroup_err("failed to create system idle thread.\n");
                        return ECGOTHER;
                }

                cgroup_dbg("created libcgroup_system_idle thread pid %d\n", child_pid);
        } else {
                child_pid = opts->pid;
        }
        cgroup_dbg("pid %d will be placed in scope %s\n", child_pid, scope_name);

        sdret = sd_bus_default_system(&bus);
        if (sdret < 0) {
                cgroup_err("failed to open the system bus: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_match_signal(bus, NULL, sender, path, interface,
                                    "JobRemoved", job_removed_callback, &job_path);
        if (sdret < 0) {
                cgroup_err("failed to install match callback: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_new_method_call(bus, &msg, sender, path, interface,
                                               "StartTransientUnit");
        if (sdret < 0) {
                cgroup_err("failed to create the systemd msg: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append(msg, "ss", scope_name, modes[opts->mode]);
        if (sdret < 0) {
                cgroup_err("failed to append the scope name: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_open_container(msg, 'a', "(sv)");
        if (sdret < 0) {
                cgroup_err("failed to open container: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append(msg, "(sv)", "Description", "s",
                                      "scope created by libcgroup");
        if (sdret < 0) {
                cgroup_err("failed to append the description: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append(msg, "(sv)", "PIDs", "au", 1, child_pid);
        if (sdret < 0) {
                cgroup_err("failed to append the PID: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append(msg, "(sv)", "Slice", "s", slice_name);
        if (sdret < 0) {
                cgroup_err("failed to append the slice: %d\n", errno);
                goto out;
        }

        if (opts->delegated == 1) {
                sdret = sd_bus_message_append(msg, "(sv)", "Delegate", "b", 1);
                if (sdret < 0) {
                        cgroup_err("failed to append delegate: %d\n", errno);
                        goto out;
                }
        }

        sdret = sd_bus_message_close_container(msg);
        if (sdret < 0) {
                cgroup_err("failed to close the container: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append(msg, "a(sa(sv))", 0);
        if (sdret < 0) {
                cgroup_err("failed to append aux structure: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_call(bus, msg, 0, &error, &reply);
        if (sdret < 0) {
                cgroup_err("sd_bus_call() failed: %d\n",
                           sd_bus_message_get_errno(msg));
                cgroup_err("error message: %s\n", error.message);
                goto out;
        }

        /* Receive the job_path from systemd */
        sdret = sd_bus_message_read(reply, "o", &job_path);
        if (sdret < 0) {
                cgroup_err("failed to read reply: %d\n", errno);
                goto out;
        }

        cgroup_dbg("job_path = %s\n", job_path);

        ret = clock_gettime(CLOCK_MONOTONIC, &start);
        if (ret < 0) {
                last_errno = errno;
                cgroup_err("Failed to get time: %d\n", errno);
                cgret = ECGOTHER;
                goto out;
        }

        /* The callback will null out the job_path pointer on completion */
        while (job_path) {
                sdret = sd_bus_process(bus, NULL);
                if (sdret < 0) {
                        cgroup_err("failed to process the sd bus: %d\n", errno);
                        goto out;
                }

                if (sdret == 0) {
                        /*
                         * Per the sd_bus_wait() man page, call this function after sd_bus_process
                         * returns zero. The wait time (usec) was somewhat arbitrarily chosen
                         */
                        sdret = sd_bus_wait(bus, 10);
                        if (sdret < 0) {
                                cgroup_err("failed to wait for sd bus: %d\n", errno);
                                goto out;
                        }
                }

                ret = clock_gettime(CLOCK_MONOTONIC, &now);
                if (ret < 0) {
                        last_errno = errno;
                        cgroup_err("Failed to get time: %d\n", errno);
                        cgret = ECGOTHER;
                        goto out;
                }

                if (elapsed_time(&start, &now) > USEC_PER_SEC) {
                        cgroup_err("The create scope command timed out\n");
                        goto out;
                }
        }

        cgret = 0;

out:
        if (cgret && opts->pid < 0)
                kill(child_pid, SIGTERM);

        sd_bus_error_free(&error);
        sd_bus_message_unref(msg);
        sd_bus_message_unref(reply);
        sd_bus_unref(bus);

        return cgret;
}

int cgroup_create_scope2(struct cgroup *cgroup, int ignore_ownership,
                         const struct cgroup_systemd_scope_opts * const opts)
{
        char *copy1 = NULL, *copy2 = NULL, *slash, *slice_name, *scope_name;
        int ret = 0;

        if (!cgroup)
                return ECGROUPNOTALLOWED;

        slash = strstr(cgroup->name, "/");
        if (!slash) {
                cgroup_err("cgroup name does not contain a slash: %s\n", cgroup->name);
                return ECGINVAL;
        }

        slash = strstr(slash + 1, "/");
        if (slash) {
                cgroup_err("cgroup name contains more than one slash: %s\n", cgroup->name);
                return ECGINVAL;
        }

        copy1 = strdup(cgroup->name);
        if (!copy1) {
                last_errno = errno;
                ret = ECGOTHER;
                goto err;
        }

        scope_name = basename(copy1);

        copy2 = strdup(cgroup->name);
        if (!copy2) {
                last_errno = errno;
                ret = ECGOTHER;
                goto err;
        }

        slice_name = dirname(copy2);

        ret = cgroup_create_scope(scope_name, slice_name, opts);
        if (ret)
                goto err;

        /*
         * Utilize cgroup_create_cgroup() to assign the requested owner/group and permissions.
         * cgroup_create_cgroup() can gracefully handle EEXIST if the cgroup already exists, so
         * we can reuse its ownership logic without penalty.
         */
        ret = cgroup_create_cgroup(cgroup, ignore_ownership);

err:
        if (copy1)
                free(copy1);
        if (copy2)
                free(copy2);

        return ret;
}

bool cgroup_is_systemd_enabled(void)
{
        return true;
}

static int append_byte_array(sd_bus_message * const msg, const char * const setting,
                             const struct cgroup_systemd_value * const value)
{
        int sdret;

        sdret = sd_bus_message_open_container(msg, SD_BUS_TYPE_STRUCT, "sv");
        if (sdret < 0) {
                cgroup_err("failed to open sv container: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append(msg, "s", setting);
        if (sdret < 0) {
                cgroup_err("failed to append the setting, %s: %d\n", setting, errno);
                goto out;
        }

        sdret = sd_bus_message_open_container(msg, 'v', "ay");
        if (sdret < 0) {
                cgroup_err("failed to open byte array container: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append_array(msg, 'y', value->byte_array, value->array_len);
        if (sdret < 0) {
                cgroup_err("failed to append byte array: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_close_container(msg);
        if (sdret < 0) {
                cgroup_err("failed to close the byte array container: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_close_container(msg);
        if (sdret < 0) {
                cgroup_err("failed to close the sv container: %d\n", errno);
                goto out;
        }

out:
        return sdret;
}

int cgroup_set_property(const char * const cgrp, const char * const setting,
                        const struct cgroup_systemd_value * const value,
                        const struct cgroup_systemd_property_opts * const opts)
{
        sd_bus_message *msg = NULL, *reply = NULL;
        sd_bus_error error = SD_BUS_ERROR_NULL;
        int sdret = 0, cgret = ECGFAIL;
        sd_bus *bus = NULL;
        char t[2];

        if (!cgrp || !setting || !value || !opts)
                return ECGINVAL;

        sdret = sd_bus_default_system(&bus);
        if (sdret < 0) {
                cgroup_err("failed to open the system bus: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_new_method_call(bus, &msg, sender, path, interface,
                                               "SetUnitProperties");
        if (sdret < 0) {
                cgroup_err("failed to create the systemd msg: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append(msg, "s", cgrp);
        if (sdret < 0) {
                cgroup_err("failed to append the cgroup name: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_append(msg, "b", opts->runtime);
        if (sdret < 0) {
                cgroup_err("failed to append the runtime value: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_open_container(msg, 'a', "(sv)");
        if (sdret < 0) {
                cgroup_err("failed to open container: %d\n", errno);
                goto out;
        }

        t[0] = value->type;
        t[1] = '\0';

        switch (value->type) {
        case SD_BUS_TYPE_BYTE:
                sdret = sd_bus_message_append(msg, "(sv)", setting, t, value->byte_value);
                break;
        case SD_BUS_TYPE_ARRAY:
                switch (value->array_type) {
                        case SD_BUS_TYPE_BYTE:
                                sdret = append_byte_array(msg, setting, value);
                                break;
                        default:
                                cgroup_err("unsupported d-bus array type: %d\n",
                                           value->array_type);
                                break;
                }
                break;
        case SD_BUS_TYPE_BOOLEAN:
                sdret = sd_bus_message_append(msg, "(sv)", setting, t, value->bool_value);
                break;
        case SD_BUS_TYPE_STRING:
                sdret = sd_bus_message_append(msg, "(sv)", setting, t, value->str_value);
                break;
        case SD_BUS_TYPE_INT32:
                sdret = sd_bus_message_append(msg, "(sv)", setting, t, value->int_value);
                break;
        case SD_BUS_TYPE_UINT32:
                sdret = sd_bus_message_append(msg, "(sv)", setting, t, value->uint_value);
                break;
        case SD_BUS_TYPE_INT64:
                sdret = sd_bus_message_append(msg, "(sv)", setting, t, value->ll_value);
                break;
        case SD_BUS_TYPE_UINT64:
                sdret = sd_bus_message_append(msg, "(sv)", setting, t, value->ull_value);
                break;
        case _SD_BUS_TYPE_INVALID:
                cgroup_err("Invalid systemd type\n");
                sdret = -1;
                break;
        }
        if (sdret < 0) {
                cgroup_err("failed to append the description: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_message_close_container(msg);
        if (sdret < 0) {
                cgroup_err("failed to close the container: %d\n", errno);
                goto out;
        }

        sdret = sd_bus_call(bus, msg, 0, &error, &reply);
        if (sdret < 0) {
                cgroup_err("sd_bus_call() failed: %d\n",
                           sd_bus_message_get_errno(msg));
                cgroup_err("error message: %s\n", error.message);
                goto out;
        }

        cgret = 0;

out:
        sd_bus_error_free(&error);
        sd_bus_message_unref(msg);
        sd_bus_message_unref(reply);
        sd_bus_unref(bus);

        return cgret;
}

static int insert_cpu_into_byte_array(unsigned int cpu, unsigned char **array,
                                      int * const array_len)
{
        unsigned int byte_num;
        void *tmp;
        int i;

        byte_num = cpu / 8;

        if (byte_num >= (*array_len)) {
                tmp = realloc((*array), sizeof(unsigned char) * (byte_num + 1));
                if (tmp == NULL)
                        return ECGOTHER;

                *array = tmp;

                for (i = (*array_len); i < byte_num + 1; i++) {
                        /* zero out the newly added memory */
                        (*array)[i] = 0;
                }

                *array_len = byte_num + 1;
        }

        (*array)[byte_num] |= 1u << (cpu % 8);

        return 0;
}

int cgroup_systemd_cpuset_str_to_byte_array(char * const in_str, unsigned char **byte_array,
                                            int * const array_len)
{
        char *comma_saveptr = NULL, *hyphen_saveptr = NULL;
        char *comma_token = NULL, *hyphen_token = NULL;
        unsigned char *tmp_array;
        unsigned int cpu;
        int start, end;
        int ret, i;

        if (!in_str || !byte_array || !array_len)
                return ECGINVAL;

        *array_len = 0;
        tmp_array = NULL;

        comma_token = strtok_r(in_str, ",", &comma_saveptr);

        do {
                if (strstr(comma_token, "-") != NULL) {
                        hyphen_token = strtok_r(comma_token, "-", &hyphen_saveptr);
                        start = atoi(hyphen_token);

                        hyphen_token = strtok_r(NULL, "-", &hyphen_saveptr);
                        end = atoi(hyphen_token);

                        for (i = start; i <= end; i++) {
                                ret = insert_cpu_into_byte_array(i, &tmp_array, array_len);
                                if (ret)
                                        return ret;
                        }
                } else {
                        /* a single cpu was provided */
                        cpu = atoi(comma_token);

                        ret = insert_cpu_into_byte_array(cpu, &tmp_array, array_len);
                        if (ret)
                                return ret;
                }
        } while ((comma_token = strtok_r(NULL, ",", &comma_saveptr)));

        *byte_array = tmp_array;

        return 0;
}
#else
int cgroup_set_default_scope_opts(struct cgroup_systemd_scope_opts * const opts)
{
        cgroup_err("Systemd support not compiled\n");
        return 1;
}

int cgroup_create_scope(const char * const scope_name, const char * const slice_name,
                        const struct cgroup_systemd_scope_opts * const opts)
{
        cgroup_err("Systemd support not compiled\n");
        return 1;
}

int cgroup_create_scope2(struct cgroup *cgroup, int ignore_ownership,
                         const struct cgroup_systemd_scope_opts * const opts)
{
        cgroup_err("Systemd support not compiled\n");
        return 1;
}

bool cgroup_is_systemd_enabled(void)
{
        return false;
}

int cgroup_set_property(const char * const cgrp, const char * const setting,
                        const struct cgroup_systemd_value * const value,
                        const struct cgroup_systemd_property_opts * const opts)
{
        cgroup_err("Systemd support not compiled\n");
        return 1;
}

int cgroup_systemd_cpuset_str_to_byte_array(char * const in_str, unsigned char **byte_array,
                                            int * const array_len)
{
        return ECGROUPUNSUPP;
}
#endif

drakenclimber / libcgroup / 14937352646

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous