[thirdparty/systemd.git] / src / network / tc / cake.c

/* SPDX-License-Identifier: LGPL-2.1+
 * Copyright © 2020 VMware, Inc. */

#include <linux/pkt_sched.h>

#include "alloc-util.h"
#include "cake.h"
#include "conf-parser.h"
#include "netlink-util.h"
#include "parse-util.h"
#include "qdisc.h"
#include "string-util.h"

static int cake_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
        CommonApplicationsKeptEnhanced *c;
        int r;

        assert(link);
        assert(qdisc);
        assert(req);

        c = CAKE(qdisc);

        r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "cake");
        if (r < 0)
                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");

        if (c->bandwidth > 0) {
                r = sd_netlink_message_append_u64(req, TCA_CAKE_BASE_RATE64, c->bandwidth);
                if (r < 0)
                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_BASE_RATE64 attribute: %m");
        }

        r = sd_netlink_message_append_s32(req, TCA_CAKE_OVERHEAD, c->overhead);
        if (r < 0)
                return log_link_error_errno(link, r, "Could not append TCA_CAKE_OVERHEAD attribute: %m");

        r = sd_netlink_message_close_container(req);
        if (r < 0)
                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");

        return 0;
}

int config_parse_cake_bandwidth(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
        CommonApplicationsKeptEnhanced *c;
        Network *network = data;
        uint64_t k;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0)
                return log_syntax(unit, LOG_ERR, filename, line, r,
                                  "More than one kind of queueing discipline, ignoring assignment: %m");

        c = CAKE(qdisc);

        if (isempty(rvalue)) {
                c->bandwidth = 0;

                qdisc = NULL;
                return 0;
        }

        r = parse_size(rvalue, 1000, &k);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, r,
                           "Failed to parse '%s=', ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }

        c->bandwidth = k/8;
        qdisc = NULL;

        return 0;
}

int config_parse_cake_overhead(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
        CommonApplicationsKeptEnhanced *c;
        Network *network = data;
        int32_t v;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0)
                return log_syntax(unit, LOG_ERR, filename, line, r,
                                  "More than one kind of queueing discipline, ignoring assignment: %m");

        c = CAKE(qdisc);

        if (isempty(rvalue)) {
                c->overhead = 0;
                qdisc = NULL;
                return 0;
        }

        r = safe_atoi32(rvalue, &v);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, r,
                           "Failed to parse '%s=', ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }
        if (v < -64 || v > 256) {
                log_syntax(unit, LOG_ERR, filename, line, 0,
                           "Invalid '%s=', ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }

        c->overhead = v;
        qdisc = NULL;
        return 0;
}

const QDiscVTable cake_vtable = {
        .object_size = sizeof(CommonApplicationsKeptEnhanced),
        .tca_kind = "cake",
        .fill_message = cake_fill_message,
};
Commit	Line	Data
ad8352f4 SS	1	/* SPDX-License-Identifier: LGPL-2.1+
	2	* Copyright © 2020 VMware, Inc. */
	3
	4	#include <linux/pkt_sched.h>
	5
	6	#include "alloc-util.h"
	7	#include "cake.h"
	8	#include "conf-parser.h"
	9	#include "netlink-util.h"
	10	#include "parse-util.h"
	11	#include "qdisc.h"
	12	#include "string-util.h"
	13
	14	static int cake_fill_message(Link link, QDisc qdisc, sd_netlink_message *req) {
	15	CommonApplicationsKeptEnhanced *c;
	16	int r;
	17
	18	assert(link);
	19	assert(qdisc);
	20	assert(req);
	21
	22	c = CAKE(qdisc);
	23
	24	r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "cake");
	25	if (r < 0)
	26	return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
	27
	28	if (c->bandwidth > 0) {
	29	r = sd_netlink_message_append_u64(req, TCA_CAKE_BASE_RATE64, c->bandwidth);
	30	if (r < 0)
	31	return log_link_error_errno(link, r, "Could not append TCA_CAKE_BASE_RATE64 attribute: %m");
	32	}
	33
	34	r = sd_netlink_message_append_s32(req, TCA_CAKE_OVERHEAD, c->overhead);
	35	if (r < 0)
	36	return log_link_error_errno(link, r, "Could not append TCA_CAKE_OVERHEAD attribute: %m");
	37
	38	r = sd_netlink_message_close_container(req);
	39	if (r < 0)
	40	return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
	41
	42	return 0;
	43	}
	44
	45	int config_parse_cake_bandwidth(
	46	const char *unit,
	47	const char *filename,
	48	unsigned line,
	49	const char *section,
	50	unsigned section_line,
	51	const char *lvalue,
	52	int ltype,
	53	const char *rvalue,
	54	void *data,
	55	void *userdata) {
	56
	57	_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
	58	CommonApplicationsKeptEnhanced *c;
	59	Network *network = data;
	60	uint64_t k;
	61	int r;
	62
	63	assert(filename);
	64	assert(lvalue);
65	assert(rvalue);
66	assert(data);
67
68	r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
69	if (r == -ENOMEM)
70	return log_oom();
71	if (r < 0)
72	return log_syntax(unit, LOG_ERR, filename, line, r,
73	"More than one kind of queueing discipline, ignoring assignment: %m");
74
75	c = CAKE(qdisc);
76
77	if (isempty(rvalue)) {
78	c->bandwidth = 0;
79
80	qdisc = NULL;
81	return 0;
82	}
83
84	r = parse_size(rvalue, 1000, &k);
85	if (r < 0) {
86	log_syntax(unit, LOG_ERR, filename, line, r,
87	"Failed to parse '%s=', ignoring assignment: %s",
88	lvalue, rvalue);
89	return 0;
90	}
91
92	c->bandwidth = k/8;
93	qdisc = NULL;
94
95	return 0;
96	}
97
98	int config_parse_cake_overhead(
99	const char *unit,
100	const char *filename,
101	unsigned line,
102	const char *section,
103	unsigned section_line,
104	const char *lvalue,
105	int ltype,
106	const char *rvalue,
107	void *data,
108	void *userdata) {
109
110	_cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
111	CommonApplicationsKeptEnhanced *c;
112	Network *network = data;
113	int32_t v;
114	int r;
115
116	assert(filename);
117	assert(lvalue);
118	assert(rvalue);
119	assert(data);
120
121	r = qdisc_new_static(QDISC_KIND_CAKE, network, filename, section_line, &qdisc);
122	if (r == -ENOMEM)
123	return log_oom();
124	if (r < 0)
125	return log_syntax(unit, LOG_ERR, filename, line, r,
126	"More than one kind of queueing discipline, ignoring assignment: %m");
127
128	c = CAKE(qdisc);
129
130	if (isempty(rvalue)) {
131	c->overhead = 0;
132	qdisc = NULL;
133	return 0;
134	}
135
136	r = safe_atoi32(rvalue, &v);
137	if (r < 0) {
138	log_syntax(unit, LOG_ERR, filename, line, r,
c03ef420 YW	139	"Failed to parse '%s=', ignoring assignment: %s",
c03ef420 YW	140	lvalue, rvalue);
ad8352f4 SS	141	return 0;
	142	}
	143	if (v < -64 \|\| v > 256) {
	144	log_syntax(unit, LOG_ERR, filename, line, 0,
c03ef420 YW	145	"Invalid '%s=', ignoring assignment: %s",
c03ef420 YW	146	lvalue, rvalue);
ad8352f4 SS	147	return 0;
	148	}
	149
	150	c->overhead = v;
	151	qdisc = NULL;
	152	return 0;
	153	}
	154
	155	const QDiscVTable cake_vtable = {
	156	.object_size = sizeof(CommonApplicationsKeptEnhanced),
	157	.tca_kind = "cake",
	158	.fill_message = cake_fill_message,
	159	};