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

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <linux/pkt_sched.h>

#include "sd-netlink.h"

#include "htb.h"
#include "log-link.h"
#include "networkd-link.h"
#include "parse-util.h"
#include "qdisc.h"
#include "string-util.h"
#include "tc-util.h"

#define HTB_DEFAULT_RATE_TO_QUANTUM  10
#define HTB_DEFAULT_MTU              1600  /* Ethernet packet length */

static int hierarchy_token_bucket_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
        HierarchyTokenBucket *htb;
        int r;

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

        assert_se(htb = HTB(qdisc));

        struct tc_htb_glob opt = {
                .version = 3,
                .rate2quantum = htb->rate_to_quantum,
                .defcls = htb->default_class,
        };

        r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "htb");
        if (r < 0)
                return r;

        r = sd_netlink_message_append_data(req, TCA_HTB_INIT, &opt, sizeof(opt));
        if (r < 0)
                return r;

        r = sd_netlink_message_close_container(req);
        if (r < 0)
                return r;
        return 0;
}

int config_parse_hierarchy_token_bucket_default_class(
                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_unref_or_set_invalidp) QDisc *qdisc = NULL;
        HierarchyTokenBucket *htb;
        Network *network = ASSERT_PTR(data);
        int r;

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

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

        htb = HTB(qdisc);

        if (isempty(rvalue)) {
                htb->default_class = 0;

                TAKE_PTR(qdisc);
                return 0;
        }

        r = safe_atou32_full(rvalue, 16, &htb->default_class);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to parse '%s=', ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }

        TAKE_PTR(qdisc);

        return 0;
}

int config_parse_hierarchy_token_bucket_u32(
                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_unref_or_set_invalidp) QDisc *qdisc = NULL;
        HierarchyTokenBucket *htb;
        Network *network = ASSERT_PTR(data);
        int r;

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

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

        htb = HTB(qdisc);

        if (isempty(rvalue)) {
                htb->rate_to_quantum = HTB_DEFAULT_RATE_TO_QUANTUM;

                TAKE_PTR(qdisc);
                return 0;
        }

        r = safe_atou32(rvalue, &htb->rate_to_quantum);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to parse '%s=', ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }

        TAKE_PTR(qdisc);

        return 0;
}

static int hierarchy_token_bucket_init(QDisc *qdisc) {
        HierarchyTokenBucket *htb;

        assert(qdisc);

        htb = HTB(qdisc);

        htb->rate_to_quantum = HTB_DEFAULT_RATE_TO_QUANTUM;

        return 0;
}

const QDiscVTable htb_vtable = {
        .object_size = sizeof(HierarchyTokenBucket),
        .tca_kind = "htb",
        .fill_message = hierarchy_token_bucket_fill_message,
        .init = hierarchy_token_bucket_init,
};

static int hierarchy_token_bucket_class_fill_message(Link *link, TClass *tclass, sd_netlink_message *req) {
        HierarchyTokenBucketClass *htb;
        uint32_t rtab[256], ctab[256];
        int r;

        assert(link);
        assert(tclass);
        assert(req);

        assert_se(htb = TCLASS_TO_HTB(tclass));

        struct tc_htb_opt opt = {
                .prio = htb->priority,
                .quantum = htb->quantum,
                .rate.rate = (htb->rate >= (1ULL << 32)) ? ~0U : htb->rate,
                .ceil.rate = (htb->ceil_rate >= (1ULL << 32)) ? ~0U : htb->ceil_rate,
                .rate.overhead = htb->overhead,
                .ceil.overhead = htb->overhead,
        };

        r = tc_transmit_time(htb->rate, htb->buffer, &opt.buffer);
        if (r < 0)
                return log_link_debug_errno(link, r, "Failed to calculate buffer size: %m");

        r = tc_transmit_time(htb->ceil_rate, htb->ceil_buffer, &opt.cbuffer);
        if (r < 0)
                return log_link_debug_errno(link, r, "Failed to calculate ceil buffer size: %m");

        r = tc_fill_ratespec_and_table(&opt.rate, rtab, htb->mtu);
        if (r < 0)
                return log_link_debug_errno(link, r, "Failed to calculate rate table: %m");

        r = tc_fill_ratespec_and_table(&opt.ceil, ctab, htb->mtu);
        if (r < 0)
                return log_link_debug_errno(link, r, "Failed to calculate ceil rate table: %m");

        r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "htb");
        if (r < 0)
                return r;

        r = sd_netlink_message_append_data(req, TCA_HTB_PARMS, &opt, sizeof(opt));
        if (r < 0)
                return r;

        if (htb->rate >= (1ULL << 32)) {
                r = sd_netlink_message_append_u64(req, TCA_HTB_RATE64, htb->rate);
                if (r < 0)
                        return r;
        }

        if (htb->ceil_rate >= (1ULL << 32)) {
                r = sd_netlink_message_append_u64(req, TCA_HTB_CEIL64, htb->ceil_rate);
                if (r < 0)
                        return r;
        }

        r = sd_netlink_message_append_data(req, TCA_HTB_RTAB, rtab, sizeof(rtab));
        if (r < 0)
                return r;

        r = sd_netlink_message_append_data(req, TCA_HTB_CTAB, ctab, sizeof(ctab));
        if (r < 0)
                return r;

        r = sd_netlink_message_close_container(req);
        if (r < 0)
                return r;

        return 0;
}

int config_parse_hierarchy_token_bucket_class_u32(
                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_(tclass_unref_or_set_invalidp) TClass *tclass = NULL;
        HierarchyTokenBucketClass *htb;
        Network *network = ASSERT_PTR(data);
        uint32_t v;
        int r;

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

        r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to create traffic control class, ignoring assignment: %m");
                return 0;
        }

        htb = TCLASS_TO_HTB(tclass);

        if (isempty(rvalue)) {
                htb->priority = 0;
                tclass = NULL;
                return 0;
        }

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

        htb->priority = v;
        tclass = NULL;

        return 0;
}

int config_parse_hierarchy_token_bucket_class_size(
                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_(tclass_unref_or_set_invalidp) TClass *tclass = NULL;
        HierarchyTokenBucketClass *htb;
        Network *network = ASSERT_PTR(data);
        uint64_t v;
        int r;

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

        r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to create traffic control class, ignoring assignment: %m");
                return 0;
        }

        htb = TCLASS_TO_HTB(tclass);

        if (isempty(rvalue)) {
                if (streq(lvalue, "QuantumBytes"))
                        htb->quantum = 0;
                else if (streq(lvalue, "MTUBytes"))
                        htb->mtu = HTB_DEFAULT_MTU;
                else if (streq(lvalue, "OverheadBytes"))
                        htb->overhead = 0;
                else if (streq(lvalue, "BufferBytes"))
                        htb->buffer = 0;
                else if (streq(lvalue, "CeilBufferBytes"))
                        htb->ceil_buffer = 0;
                else
                        assert_not_reached();

                tclass = NULL;
                return 0;
        }

        r = parse_size(rvalue, 1024, &v);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to parse '%s=', ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }
        if ((streq(lvalue, "OverheadBytes") && v > UINT16_MAX) || v > UINT32_MAX) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "Invalid '%s=', ignoring assignment: %s",
                           lvalue, rvalue);
                return 0;
        }

        if (streq(lvalue, "QuantumBytes"))
                htb->quantum = v;
        else if (streq(lvalue, "OverheadBytes"))
                htb->overhead = v;
        else if (streq(lvalue, "MTUBytes"))
                htb->mtu = v;
        else if (streq(lvalue, "BufferBytes"))
                htb->buffer = v;
        else if (streq(lvalue, "CeilBufferBytes"))
                htb->ceil_buffer = v;
        else
                assert_not_reached();

        tclass = NULL;

        return 0;
}

int config_parse_hierarchy_token_bucket_class_rate(
                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_(tclass_unref_or_set_invalidp) TClass *tclass = NULL;
        HierarchyTokenBucketClass *htb;
        Network *network = ASSERT_PTR(data);
        uint64_t *v;
        int r;

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

        r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to create traffic control class, ignoring assignment: %m");
                return 0;
        }

        htb = TCLASS_TO_HTB(tclass);
        if (streq(lvalue, "Rate"))
                v = &htb->rate;
        else if (streq(lvalue, "CeilRate"))
                v = &htb->ceil_rate;
        else
                assert_not_reached();

        if (isempty(rvalue)) {
                *v = 0;

                tclass = NULL;
                return 0;
        }

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

        *v /= 8;
        tclass = NULL;

        return 0;
}

static int hierarchy_token_bucket_class_init(TClass *tclass) {
        HierarchyTokenBucketClass *htb;

        assert(tclass);

        htb = TCLASS_TO_HTB(tclass);

        htb->mtu = HTB_DEFAULT_MTU;

        return 0;
}

static int hierarchy_token_bucket_class_verify(TClass *tclass) {
        HierarchyTokenBucketClass *htb;
        uint32_t hz;
        int r;

        assert(tclass);

        htb = TCLASS_TO_HTB(tclass);

        if (htb->rate == 0)
                return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
                                         "%s: Rate= is mandatory. "
                                         "Ignoring [HierarchyTokenBucketClass] section from line %u.",
                                         tclass->section->filename, tclass->section->line);

        /* if CeilRate= setting is missing, use the same as Rate= */
        if (htb->ceil_rate == 0)
                htb->ceil_rate = htb->rate;

        r = tc_init(NULL, &hz);
        if (r < 0)
                return log_error_errno(r, "Failed to read /proc/net/psched: %m");

        /* Kernel would never hand us 0 Hz. */
        assert(hz > 0);
        if (htb->buffer == 0)
                htb->buffer = htb->rate / hz + htb->mtu;
        if (htb->ceil_buffer == 0)
                htb->ceil_buffer = htb->ceil_rate / hz + htb->mtu;

        return 0;
}

const TClassVTable htb_tclass_vtable = {
        .object_size = sizeof(HierarchyTokenBucketClass),
        .tca_kind = "htb",
        .fill_message = hierarchy_token_bucket_class_fill_message,
        .init = hierarchy_token_bucket_class_init,
        .verify = hierarchy_token_bucket_class_verify,
};
Commit	Line	Data
	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
	2
	3	#include <linux/pkt_sched.h>
	4
	5	#include "sd-netlink.h"
	6
	7	#include "htb.h"
	8	#include "log-link.h"
	9	#include "networkd-link.h"
	10	#include "parse-util.h"
	11	#include "qdisc.h"
	12	#include "string-util.h"
	13	#include "tc-util.h"
	14
	15	#define HTB_DEFAULT_RATE_TO_QUANTUM 10
	16	#define HTB_DEFAULT_MTU 1600 /* Ethernet packet length */
	17
	18	static int hierarchy_token_bucket_fill_message(Link link, QDisc qdisc, sd_netlink_message *req) {
	19	HierarchyTokenBucket *htb;
	20	int r;
	21
	22	assert(link);
	23	assert(qdisc);
	24	assert(req);
	25
	26	assert_se(htb = HTB(qdisc));
	27
	28	struct tc_htb_glob opt = {
	29	.version = 3,
	30	.rate2quantum = htb->rate_to_quantum,
	31	.defcls = htb->default_class,
	32	};
	33
	34	r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "htb");
	35	if (r < 0)
	36	return r;
	37
	38	r = sd_netlink_message_append_data(req, TCA_HTB_INIT, &opt, sizeof(opt));
	39	if (r < 0)
	40	return r;
	41
	42	r = sd_netlink_message_close_container(req);
	43	if (r < 0)
	44	return r;
	45	return 0;
	46	}
	47
	48	int config_parse_hierarchy_token_bucket_default_class(
	49	const char *unit,
	50	const char *filename,
	51	unsigned line,
	52	const char *section,
	53	unsigned section_line,
	54	const char *lvalue,
	55	int ltype,
	56	const char *rvalue,
	57	void *data,
	58	void *userdata) {
	59
	60	_cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
	61	HierarchyTokenBucket *htb;
	62	Network *network = ASSERT_PTR(data);
	63	int r;
	64
	65	assert(filename);
	66	assert(lvalue);
	67	assert(rvalue);
	68
	69	r = qdisc_new_static(QDISC_KIND_HTB, network, filename, section_line, &qdisc);
	70	if (r == -ENOMEM)
	71	return log_oom();
	72	if (r < 0) {
	73	log_syntax(unit, LOG_WARNING, filename, line, r,
	74	"More than one kind of queueing discipline, ignoring assignment: %m");
	75	return 0;
	76	}
	77
	78	htb = HTB(qdisc);
	79
	80	if (isempty(rvalue)) {
	81	htb->default_class = 0;
	82
	83	TAKE_PTR(qdisc);
	84	return 0;
	85	}
	86
	87	r = safe_atou32_full(rvalue, 16, &htb->default_class);
	88	if (r < 0) {
	89	log_syntax(unit, LOG_WARNING, filename, line, r,
	90	"Failed to parse '%s=', ignoring assignment: %s",
	91	lvalue, rvalue);
	92	return 0;
	93	}
	94
	95	TAKE_PTR(qdisc);
	96
	97	return 0;
	98	}
	99
	100	int config_parse_hierarchy_token_bucket_u32(
	101	const char *unit,
	102	const char *filename,
	103	unsigned line,
	104	const char *section,
	105	unsigned section_line,
	106	const char *lvalue,
	107	int ltype,
	108	const char *rvalue,
	109	void *data,
	110	void *userdata) {
	111
	112	_cleanup_(qdisc_unref_or_set_invalidp) QDisc *qdisc = NULL;
	113	HierarchyTokenBucket *htb;
	114	Network *network = ASSERT_PTR(data);
	115	int r;
	116
	117	assert(filename);
	118	assert(lvalue);
	119	assert(rvalue);
	120
	121	r = qdisc_new_static(QDISC_KIND_HTB, network, filename, section_line, &qdisc);
	122	if (r == -ENOMEM)
	123	return log_oom();
	124	if (r < 0) {
	125	log_syntax(unit, LOG_WARNING, filename, line, r,
	126	"More than one kind of queueing discipline, ignoring assignment: %m");
	127	return 0;
	128	}
	129
	130	htb = HTB(qdisc);
	131
	132	if (isempty(rvalue)) {
	133	htb->rate_to_quantum = HTB_DEFAULT_RATE_TO_QUANTUM;
	134
	135	TAKE_PTR(qdisc);
	136	return 0;
	137	}
	138
	139	r = safe_atou32(rvalue, &htb->rate_to_quantum);
	140	if (r < 0) {
	141	log_syntax(unit, LOG_WARNING, filename, line, r,
	142	"Failed to parse '%s=', ignoring assignment: %s",
	143	lvalue, rvalue);
	144	return 0;
	145	}
	146
	147	TAKE_PTR(qdisc);
	148
	149	return 0;
	150	}
	151
	152	static int hierarchy_token_bucket_init(QDisc *qdisc) {
	153	HierarchyTokenBucket *htb;
	154
	155	assert(qdisc);
	156
	157	htb = HTB(qdisc);
	158
	159	htb->rate_to_quantum = HTB_DEFAULT_RATE_TO_QUANTUM;
	160
	161	return 0;
	162	}
	163
	164	const QDiscVTable htb_vtable = {
	165	.object_size = sizeof(HierarchyTokenBucket),
	166	.tca_kind = "htb",
	167	.fill_message = hierarchy_token_bucket_fill_message,
	168	.init = hierarchy_token_bucket_init,
	169	};
	170
	171	static int hierarchy_token_bucket_class_fill_message(Link link, TClass tclass, sd_netlink_message *req) {
	172	HierarchyTokenBucketClass *htb;
	173	uint32_t rtab[256], ctab[256];
	174	int r;
	175
	176	assert(link);
	177	assert(tclass);
	178	assert(req);
	179
	180	assert_se(htb = TCLASS_TO_HTB(tclass));
	181
	182	struct tc_htb_opt opt = {
	183	.prio = htb->priority,
	184	.quantum = htb->quantum,
	185	.rate.rate = (htb->rate >= (1ULL << 32)) ? ~0U : htb->rate,
	186	.ceil.rate = (htb->ceil_rate >= (1ULL << 32)) ? ~0U : htb->ceil_rate,
	187	.rate.overhead = htb->overhead,
	188	.ceil.overhead = htb->overhead,
	189	};
	190
	191	r = tc_transmit_time(htb->rate, htb->buffer, &opt.buffer);
	192	if (r < 0)
	193	return log_link_debug_errno(link, r, "Failed to calculate buffer size: %m");
	194
	195	r = tc_transmit_time(htb->ceil_rate, htb->ceil_buffer, &opt.cbuffer);
	196	if (r < 0)
	197	return log_link_debug_errno(link, r, "Failed to calculate ceil buffer size: %m");
	198
	199	r = tc_fill_ratespec_and_table(&opt.rate, rtab, htb->mtu);
	200	if (r < 0)
	201	return log_link_debug_errno(link, r, "Failed to calculate rate table: %m");
	202
	203	r = tc_fill_ratespec_and_table(&opt.ceil, ctab, htb->mtu);
	204	if (r < 0)
	205	return log_link_debug_errno(link, r, "Failed to calculate ceil rate table: %m");
	206
	207	r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "htb");
	208	if (r < 0)
	209	return r;
	210
	211	r = sd_netlink_message_append_data(req, TCA_HTB_PARMS, &opt, sizeof(opt));
	212	if (r < 0)
	213	return r;
	214
	215	if (htb->rate >= (1ULL << 32)) {
	216	r = sd_netlink_message_append_u64(req, TCA_HTB_RATE64, htb->rate);
	217	if (r < 0)
	218	return r;
	219	}
	220
	221	if (htb->ceil_rate >= (1ULL << 32)) {
	222	r = sd_netlink_message_append_u64(req, TCA_HTB_CEIL64, htb->ceil_rate);
	223	if (r < 0)
	224	return r;
	225	}
	226
	227	r = sd_netlink_message_append_data(req, TCA_HTB_RTAB, rtab, sizeof(rtab));
	228	if (r < 0)
	229	return r;
	230
	231	r = sd_netlink_message_append_data(req, TCA_HTB_CTAB, ctab, sizeof(ctab));
	232	if (r < 0)
	233	return r;
	234
	235	r = sd_netlink_message_close_container(req);
	236	if (r < 0)
	237	return r;
	238
	239	return 0;
	240	}
	241
	242	int config_parse_hierarchy_token_bucket_class_u32(
	243	const char *unit,
	244	const char *filename,
	245	unsigned line,
	246	const char *section,
	247	unsigned section_line,
	248	const char *lvalue,
	249	int ltype,
	250	const char *rvalue,
	251	void *data,
	252	void *userdata) {
	253
	254	_cleanup_(tclass_unref_or_set_invalidp) TClass *tclass = NULL;
	255	HierarchyTokenBucketClass *htb;
	256	Network *network = ASSERT_PTR(data);
	257	uint32_t v;
	258	int r;
	259
	260	assert(filename);
	261	assert(lvalue);
	262	assert(rvalue);
	263
	264	r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
	265	if (r == -ENOMEM)
	266	return log_oom();
	267	if (r < 0) {
	268	log_syntax(unit, LOG_WARNING, filename, line, r,
	269	"Failed to create traffic control class, ignoring assignment: %m");
	270	return 0;
	271	}
	272
	273	htb = TCLASS_TO_HTB(tclass);
	274
	275	if (isempty(rvalue)) {
	276	htb->priority = 0;
	277	tclass = NULL;
	278	return 0;
	279	}
	280
	281	r = safe_atou32(rvalue, &v);
	282	if (r < 0) {
	283	log_syntax(unit, LOG_WARNING, filename, line, r,
	284	"Failed to parse '%s=', ignoring assignment: %s",
	285	lvalue, rvalue);
	286	return 0;
	287	}
	288
	289	htb->priority = v;
	290	tclass = NULL;
	291
	292	return 0;
	293	}
	294
	295	int config_parse_hierarchy_token_bucket_class_size(
	296	const char *unit,
	297	const char *filename,
	298	unsigned line,
	299	const char *section,
	300	unsigned section_line,
	301	const char *lvalue,
	302	int ltype,
	303	const char *rvalue,
	304	void *data,
	305	void *userdata) {
	306
	307	_cleanup_(tclass_unref_or_set_invalidp) TClass *tclass = NULL;
	308	HierarchyTokenBucketClass *htb;
	309	Network *network = ASSERT_PTR(data);
	310	uint64_t v;
	311	int r;
	312
	313	assert(filename);
	314	assert(lvalue);
	315	assert(rvalue);
	316
	317	r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
	318	if (r == -ENOMEM)
	319	return log_oom();
	320	if (r < 0) {
	321	log_syntax(unit, LOG_WARNING, filename, line, r,
	322	"Failed to create traffic control class, ignoring assignment: %m");
	323	return 0;
	324	}
	325
	326	htb = TCLASS_TO_HTB(tclass);
	327
	328	if (isempty(rvalue)) {
	329	if (streq(lvalue, "QuantumBytes"))
	330	htb->quantum = 0;
	331	else if (streq(lvalue, "MTUBytes"))
	332	htb->mtu = HTB_DEFAULT_MTU;
	333	else if (streq(lvalue, "OverheadBytes"))
	334	htb->overhead = 0;
	335	else if (streq(lvalue, "BufferBytes"))
	336	htb->buffer = 0;
	337	else if (streq(lvalue, "CeilBufferBytes"))
	338	htb->ceil_buffer = 0;
	339	else
	340	assert_not_reached();
	341
	342	tclass = NULL;
	343	return 0;
	344	}
	345
	346	r = parse_size(rvalue, 1024, &v);
	347	if (r < 0) {
	348	log_syntax(unit, LOG_WARNING, filename, line, r,
	349	"Failed to parse '%s=', ignoring assignment: %s",
	350	lvalue, rvalue);
	351	return 0;
	352	}
	353	if ((streq(lvalue, "OverheadBytes") && v > UINT16_MAX) \|\| v > UINT32_MAX) {
	354	log_syntax(unit, LOG_WARNING, filename, line, 0,
	355	"Invalid '%s=', ignoring assignment: %s",
	356	lvalue, rvalue);
	357	return 0;
	358	}
	359
	360	if (streq(lvalue, "QuantumBytes"))
	361	htb->quantum = v;
	362	else if (streq(lvalue, "OverheadBytes"))
	363	htb->overhead = v;
	364	else if (streq(lvalue, "MTUBytes"))
	365	htb->mtu = v;
	366	else if (streq(lvalue, "BufferBytes"))
	367	htb->buffer = v;
	368	else if (streq(lvalue, "CeilBufferBytes"))
	369	htb->ceil_buffer = v;
	370	else
	371	assert_not_reached();
	372
	373	tclass = NULL;
	374
	375	return 0;
	376	}
	377
	378	int config_parse_hierarchy_token_bucket_class_rate(
	379	const char *unit,
	380	const char *filename,
	381	unsigned line,
	382	const char *section,
	383	unsigned section_line,
	384	const char *lvalue,
	385	int ltype,
	386	const char *rvalue,
	387	void *data,
	388	void *userdata) {
	389
	390	_cleanup_(tclass_unref_or_set_invalidp) TClass *tclass = NULL;
	391	HierarchyTokenBucketClass *htb;
	392	Network *network = ASSERT_PTR(data);
	393	uint64_t *v;
	394	int r;
	395
	396	assert(filename);
	397	assert(lvalue);
	398	assert(rvalue);
	399
	400	r = tclass_new_static(TCLASS_KIND_HTB, network, filename, section_line, &tclass);
	401	if (r == -ENOMEM)
	402	return log_oom();
	403	if (r < 0) {
	404	log_syntax(unit, LOG_WARNING, filename, line, r,
	405	"Failed to create traffic control class, ignoring assignment: %m");
	406	return 0;
	407	}
	408
	409	htb = TCLASS_TO_HTB(tclass);
	410	if (streq(lvalue, "Rate"))
	411	v = &htb->rate;
	412	else if (streq(lvalue, "CeilRate"))
	413	v = &htb->ceil_rate;
	414	else
	415	assert_not_reached();
	416
	417	if (isempty(rvalue)) {
	418	*v = 0;
	419
	420	tclass = NULL;
	421	return 0;
	422	}
	423
	424	r = parse_size(rvalue, 1000, v);
	425	if (r < 0) {
	426	log_syntax(unit, LOG_WARNING, filename, line, r,
	427	"Failed to parse '%s=', ignoring assignment: %s",
	428	lvalue, rvalue);
	429	return 0;
	430	}
	431
	432	*v /= 8;
	433	tclass = NULL;
	434
	435	return 0;
	436	}
	437
	438	static int hierarchy_token_bucket_class_init(TClass *tclass) {
	439	HierarchyTokenBucketClass *htb;
	440
	441	assert(tclass);
	442
	443	htb = TCLASS_TO_HTB(tclass);
	444
	445	htb->mtu = HTB_DEFAULT_MTU;
	446
	447	return 0;
	448	}
	449
	450	static int hierarchy_token_bucket_class_verify(TClass *tclass) {
	451	HierarchyTokenBucketClass *htb;
	452	uint32_t hz;
	453	int r;
	454
	455	assert(tclass);
	456
	457	htb = TCLASS_TO_HTB(tclass);
	458
	459	if (htb->rate == 0)
	460	return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
	461	"%s: Rate= is mandatory. "
	462	"Ignoring [HierarchyTokenBucketClass] section from line %u.",
	463	tclass->section->filename, tclass->section->line);
	464
	465	/* if CeilRate= setting is missing, use the same as Rate= */
	466	if (htb->ceil_rate == 0)
	467	htb->ceil_rate = htb->rate;
	468
	469	r = tc_init(NULL, &hz);
	470	if (r < 0)
	471	return log_error_errno(r, "Failed to read /proc/net/psched: %m");
	472
	473	/* Kernel would never hand us 0 Hz. */
	474	assert(hz > 0);
	475	if (htb->buffer == 0)
	476	htb->buffer = htb->rate / hz + htb->mtu;
	477	if (htb->ceil_buffer == 0)
	478	htb->ceil_buffer = htb->ceil_rate / hz + htb->mtu;
	479
	480	return 0;
	481	}
	482
	483	const TClassVTable htb_tclass_vtable = {
	484	.object_size = sizeof(HierarchyTokenBucketClass),
	485	.tca_kind = "htb",
	486	.fill_message = hierarchy_token_bucket_class_fill_message,
	487	.init = hierarchy_token_bucket_class_init,
	488	.verify = hierarchy_token_bucket_class_verify,
	489	};