src/network/tc/tbf.c

   1 /* SPDX-License-Identifier: LGPL-2.1+
   2  * Copyright © 2019 VMware, Inc. */
   3
   4 #include <linux/pkt_sched.h>
   5 #include <math.h>
   6
   7 #include "alloc-util.h"
   8 #include "conf-parser.h"
   9 #include "netem.h"
  10 #include "netlink-util.h"
  11 #include "networkd-manager.h"
  12 #include "parse-util.h"
  13 #include "qdisc.h"
  14 #include "string-util.h"
  15 #include "strv.h"
  16 #include "tc-util.h"
  17
  18 static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
  19         uint32_t rtab[256], ptab[256];
  20         struct tc_tbf_qopt opt = {};
  21         TokenBucketFilter *tbf;
  22         int r;
  23
  24         assert(link);
  25         assert(qdisc);
  26         assert(req);
  27
  28         tbf = TBF(qdisc);
  29
  30         opt.rate.rate = tbf->rate >= (1ULL << 32) ? ~0U : tbf->rate;
  31         opt.peakrate.rate = tbf->peak_rate >= (1ULL << 32) ? ~0U : tbf->peak_rate;
  32
  33         if (tbf->limit > 0)
  34                 opt.limit = tbf->limit;
  35         else {
  36                 double lim, lim2;
  37
  38                 lim = tbf->rate * (double) tbf->latency / USEC_PER_SEC + tbf->burst;
  39                 if (tbf->peak_rate > 0) {
  40                         lim2 = tbf->peak_rate * (double) tbf->latency / USEC_PER_SEC + tbf->mtu;
  41                         lim = MIN(lim, lim2);
  42                 }
  43                 opt.limit = lim;
  44         }
  45
  46         opt.rate.mpu = tbf->mpu;
  47
  48         r = tc_fill_ratespec_and_table(&opt.rate, rtab, tbf->mtu);
  49         if (r < 0)
  50                 return log_link_error_errno(link, r, "Failed to calculate ratespec: %m");
  51
  52         r = tc_transmit_time(opt.rate.rate, tbf->burst, &opt.buffer);
  53         if (r < 0)
  54                 return log_link_error_errno(link, r, "Failed to calculate buffer size: %m");
  55
  56         if (opt.peakrate.rate > 0) {
  57                 opt.peakrate.mpu = tbf->mpu;
  58
  59                 r = tc_fill_ratespec_and_table(&opt.peakrate, ptab, tbf->mtu);
  60                 if (r < 0)
  61                         return log_link_error_errno(link, r, "Failed to calculate ratespec: %m");
  62
  63                 r = tc_transmit_time(opt.peakrate.rate, tbf->mtu, &opt.mtu);
  64                 if (r < 0)
  65                         return log_link_error_errno(link, r, "Failed to calculate mtu size: %m");
  66         }
  67
  68         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "tbf");
  69         if (r < 0)
  70                 return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
  71
  72         r = sd_netlink_message_append_data(req, TCA_TBF_PARMS, &opt, sizeof(struct tc_tbf_qopt));
  73         if (r < 0)
  74                 return log_link_error_errno(link, r, "Could not append TCA_TBF_PARMS attribute: %m");
  75
  76         r = sd_netlink_message_append_data(req, TCA_TBF_BURST, &tbf->burst, sizeof(tbf->burst));
  77         if (r < 0)
  78                 return log_link_error_errno(link, r, "Could not append TCA_TBF_BURST attribute: %m");
  79
  80         if (tbf->rate >= (1ULL << 32)) {
  81                 r = sd_netlink_message_append_u64(req, TCA_TBF_RATE64, tbf->rate);
  82                 if (r < 0)
  83                         return log_link_error_errno(link, r, "Could not append TCA_TBF_RATE64 attribute: %m");
  84         }
  85
  86         r = sd_netlink_message_append_data(req, TCA_TBF_RTAB, rtab, sizeof(rtab));
  87         if (r < 0)
  88                 return log_link_error_errno(link, r, "Could not append TCA_TBF_RTAB attribute: %m");
  89
  90         if (opt.peakrate.rate > 0) {
  91                 if (tbf->peak_rate >= (1ULL << 32)) {
  92                         r = sd_netlink_message_append_u64(req, TCA_TBF_PRATE64, tbf->peak_rate);
  93                         if (r < 0)
  94                                 return log_link_error_errno(link, r, "Could not append TCA_TBF_PRATE64 attribute: %m");
  95                 }
  96
  97                 r = sd_netlink_message_append_u32(req, TCA_TBF_PBURST, tbf->mtu);
  98                 if (r < 0)
  99                         return log_link_error_errno(link, r, "Could not append TCA_TBF_PBURST attribute: %m");
 100
 101                 r = sd_netlink_message_append_data(req, TCA_TBF_PTAB, ptab, sizeof(ptab));
 102                 if (r < 0)
 103                         return log_link_error_errno(link, r, "Could not append TCA_TBF_PTAB attribute: %m");
 104         }
 105
 106         r = sd_netlink_message_close_container(req);
 107         if (r < 0)
 108                 return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
 109
 110         return 0;
 111 }
 112
 113 int config_parse_token_bucket_filter_size(
 114                 const char *unit,
 115                 const char *filename,
 116                 unsigned line,
 117                 const char *section,
 118                 unsigned section_line,
 119                 const char *lvalue,
 120                 int ltype,
 121                 const char *rvalue,
 122                 void *data,
 123                 void *userdata) {
 124
 125         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 126         Network *network = data;
 127         TokenBucketFilter *tbf;
 128         uint64_t k;
 129         int r;
 130
 131         assert(filename);
 132         assert(lvalue);
 133         assert(rvalue);
 134         assert(data);
 135
 136         r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
 137         if (r == -ENOMEM)
 138                 return log_oom();
 139         if (r < 0)
 140                 return log_syntax(unit, LOG_ERR, filename, line, r,
 141                                   "More than one kind of queueing discipline, ignoring assignment: %m");
 142
 143         tbf = TBF(qdisc);
 144
 145         if (isempty(rvalue)) {
 146                 if (STR_IN_SET(lvalue, "BurstBytes", "Burst"))
 147                         tbf->burst = 0;
 148                 else if (STR_IN_SET(lvalue, "LimitBytes", "LimitSize"))
 149                         tbf->limit = 0;
 150                 else if (streq(lvalue, "MTUBytes"))
 151                         tbf->mtu = 0;
 152                 else if (streq(lvalue, "MPUBytes"))
 153                         tbf->mpu = 0;
 154                 else
 155                         assert_not_reached("unknown lvalue");
 156
 157                 qdisc = NULL;
 158                 return 0;
 159         }
 160
 161         r = parse_size(rvalue, 1024, &k);
 162         if (r < 0) {
 163                 log_syntax(unit, LOG_ERR, filename, line, r,
 164                            "Failed to parse '%s=', ignoring assignment: %s",
 165                            lvalue, rvalue);
 166                 return 0;
 167         }
 168
 169         if (STR_IN_SET(lvalue, "BurstBytes", "Burst"))
 170                 tbf->burst = k;
 171         else if (STR_IN_SET(lvalue, "LimitBytes", "LimitSize"))
 172                 tbf->limit = k;
 173         else if (streq(lvalue, "MPUBytes"))
 174                 tbf->mpu = k;
 175         else if (streq(lvalue, "MTUBytes"))
 176                 tbf->mtu = k;
 177         else
 178                 assert_not_reached("unknown lvalue");
 179
 180         qdisc = NULL;
 181
 182         return 0;
 183 }
 184
 185 int config_parse_token_bucket_filter_rate(
 186                 const char *unit,
 187                 const char *filename,
 188                 unsigned line,
 189                 const char *section,
 190                 unsigned section_line,
 191                 const char *lvalue,
 192                 int ltype,
 193                 const char *rvalue,
 194                 void *data,
 195                 void *userdata) {
 196
 197         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 198         Network *network = data;
 199         TokenBucketFilter *tbf;
 200         uint64_t k, *p;
 201         int r;
 202
 203         assert(filename);
 204         assert(lvalue);
 205         assert(rvalue);
 206         assert(data);
 207
 208         r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
 209         if (r == -ENOMEM)
 210                 return log_oom();
 211         if (r < 0)
 212                 return log_syntax(unit, LOG_ERR, filename, line, r,
 213                                   "More than one kind of queueing discipline, ignoring assignment: %m");
 214
 215         tbf = TBF(qdisc);
 216         if (streq(lvalue, "Rate"))
 217                 p = &tbf->rate;
 218         else if (streq(lvalue, "PeakRate"))
 219                 p = &tbf->peak_rate;
 220         else
 221                 assert_not_reached("unknown lvalue");
 222
 223         if (isempty(rvalue)) {
 224                 *p = 0;
 225
 226                 qdisc = NULL;
 227                 return 0;
 228         }
 229
 230         r = parse_size(rvalue, 1000, &k);
 231         if (r < 0) {
 232                 log_syntax(unit, LOG_ERR, filename, line, r,
 233                            "Failed to parse '%s=', ignoring assignment: %s",
 234                            lvalue, rvalue);
 235                 return 0;
 236         }
 237
 238         *p = k / 8;
 239
 240         qdisc = NULL;
 241
 242         return 0;
 243 }
 244
 245 int config_parse_token_bucket_filter_latency(
 246                 const char *unit,
 247                 const char *filename,
 248                 unsigned line,
 249                 const char *section,
 250                 unsigned section_line,
 251                 const char *lvalue,
 252                 int ltype,
 253                 const char *rvalue,
 254                 void *data,
 255                 void *userdata) {
 256
 257         _cleanup_(qdisc_free_or_set_invalidp) QDisc *qdisc = NULL;
 258         Network *network = data;
 259         TokenBucketFilter *tbf;
 260         usec_t u;
 261         int r;
 262
 263         assert(filename);
 264         assert(lvalue);
 265         assert(rvalue);
 266         assert(data);
 267
 268         r = qdisc_new_static(QDISC_KIND_TBF, network, filename, section_line, &qdisc);
 269         if (r == -ENOMEM)
 270                 return log_oom();
 271         if (r < 0)
 272                 return log_syntax(unit, LOG_ERR, filename, line, r,
 273                                   "More than one kind of queueing discipline, ignoring assignment: %m");
 274
 275         tbf = TBF(qdisc);
 276
 277         if (isempty(rvalue)) {
 278                 tbf->latency = 0;
 279
 280                 qdisc = NULL;
 281                 return 0;
 282         }
 283
 284         r = parse_sec(rvalue, &u);
 285         if (r < 0) {
 286                 log_syntax(unit, LOG_ERR, filename, line, r,
 287                            "Failed to parse '%s=', ignoring assignment: %s",
 288                            lvalue, rvalue);
 289                 return 0;
 290         }
 291
 292         tbf->latency = u;
 293
 294         qdisc = NULL;
 295
 296         return 0;
 297 }
 298
 299 static int token_bucket_filter_verify(QDisc *qdisc) {
 300         TokenBucketFilter *tbf = TBF(qdisc);
 301
 302         if (tbf->limit > 0 && tbf->latency > 0)
 303                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 304                                          "%s: Specifying both LimitSize= and LatencySec= is not allowed. "
 305                                          "Ignoring [TokenBucketFilter] section from line %u.",
 306                                          qdisc->section->filename, qdisc->section->line);
 307
 308         if (tbf->limit == 0 && tbf->latency == 0)
 309                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 310                                          "%s: Either LimitSize= or LatencySec= is required. "
 311                                          "Ignoring [TokenBucketFilter] section from line %u.",
 312                                          qdisc->section->filename, qdisc->section->line);
 313
 314         if (tbf->rate == 0)
 315                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 316                                          "%s: Rate= is mandatory. "
 317                                          "Ignoring [TokenBucketFilter] section from line %u.",
 318                                          qdisc->section->filename, qdisc->section->line);
 319
 320         if (tbf->burst == 0)
 321                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 322                                          "%s: Burst= is mandatory. "
 323                                          "Ignoring [TokenBucketFilter] section from line %u.",
 324                                          qdisc->section->filename, qdisc->section->line);
 325
 326         if (tbf->peak_rate > 0 && tbf->mtu == 0)
 327                 return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
 328                                          "%s: MTUBytes= is mandatory when PeakRate= is specified. "
 329                                          "Ignoring [TokenBucketFilter] section from line %u.",
 330                                          qdisc->section->filename, qdisc->section->line);
 331
 332         return 0;
 333 }
 334
 335 const QDiscVTable tbf_vtable = {
 336         .object_size = sizeof(TokenBucketFilter),
 337         .tca_kind = "tbf",
 338         .fill_message = token_bucket_filter_fill_message,
 339         .verify = token_bucket_filter_verify
 340 };