~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/samples/bpf/hbm.c

Version: ~ [ linux-5.16-rc1 ] ~ [ linux-5.15.2 ] ~ [ linux-5.14.18 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.79 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.159 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.217 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.255 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.290 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.292 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /* Copyright (c) 2019 Facebook
  3  *
  4  * This program is free software; you can redistribute it and/or
  5  * modify it under the terms of version 2 of the GNU General Public
  6  * License as published by the Free Software Foundation.
  7  *
  8  * Example program for Host Bandwidth Managment
  9  *
 10  * This program loads a cgroup skb BPF program to enforce cgroup output
 11  * (egress) or input (ingress) bandwidth limits.
 12  *
 13  * USAGE: hbm [-d] [-l] [-n <id>] [-r <rate>] [-s] [-t <secs>] [-w] [-h] [prog]
 14  *   Where:
 15  *    -d        Print BPF trace debug buffer
 16  *    -l        Also limit flows doing loopback
 17  *    -n <#>    To create cgroup \"/hbm#\" and attach prog
 18  *              Default is /hbm1
 19  *    --no_cn   Do not return cn notifications
 20  *    -r <rate> Rate limit in Mbps
 21  *    -s        Get HBM stats (marked, dropped, etc.)
 22  *    -t <time> Exit after specified seconds (default is 0)
 23  *    -w        Work conserving flag. cgroup can increase its bandwidth
 24  *              beyond the rate limit specified while there is available
 25  *              bandwidth. Current implementation assumes there is only
 26  *              NIC (eth0), but can be extended to support multiple NICs.
 27  *              Currrently only supported for egress.
 28  *    -h        Print this info
 29  *    prog      BPF program file name. Name defaults to hbm_out_kern.o
 30  */
 31 
 32 #define _GNU_SOURCE
 33 
 34 #include <stdio.h>
 35 #include <stdlib.h>
 36 #include <assert.h>
 37 #include <sys/resource.h>
 38 #include <sys/time.h>
 39 #include <unistd.h>
 40 #include <errno.h>
 41 #include <fcntl.h>
 42 #include <linux/unistd.h>
 43 
 44 #include <linux/bpf.h>
 45 #include <bpf/bpf.h>
 46 #include <getopt.h>
 47 
 48 #include "bpf_load.h"
 49 #include "bpf_rlimit.h"
 50 #include "cgroup_helpers.h"
 51 #include "hbm.h"
 52 #include "bpf_util.h"
 53 #include <bpf/bpf.h>
 54 #include <bpf/libbpf.h>
 55 
 56 bool outFlag = true;
 57 int minRate = 1000;             /* cgroup rate limit in Mbps */
 58 int rate = 1000;                /* can grow if rate conserving is enabled */
 59 int dur = 1;
 60 bool stats_flag;
 61 bool loopback_flag;
 62 bool debugFlag;
 63 bool work_conserving_flag;
 64 bool no_cn_flag;
 65 bool edt_flag;
 66 
 67 static void Usage(void);
 68 static void read_trace_pipe2(void);
 69 static void do_error(char *msg, bool errno_flag);
 70 
 71 #define DEBUGFS "/sys/kernel/debug/tracing/"
 72 
 73 struct bpf_object *obj;
 74 int bpfprog_fd;
 75 int cgroup_storage_fd;
 76 
 77 static void read_trace_pipe2(void)
 78 {
 79         int trace_fd;
 80         FILE *outf;
 81         char *outFname = "hbm_out.log";
 82 
 83         trace_fd = open(DEBUGFS "trace_pipe", O_RDONLY, 0);
 84         if (trace_fd < 0) {
 85                 printf("Error opening trace_pipe\n");
 86                 return;
 87         }
 88 
 89 //      Future support of ingress
 90 //      if (!outFlag)
 91 //              outFname = "hbm_in.log";
 92         outf = fopen(outFname, "w");
 93 
 94         if (outf == NULL)
 95                 printf("Error creating %s\n", outFname);
 96 
 97         while (1) {
 98                 static char buf[4097];
 99                 ssize_t sz;
100 
101                 sz = read(trace_fd, buf, sizeof(buf) - 1);
102                 if (sz > 0) {
103                         buf[sz] = 0;
104                         puts(buf);
105                         if (outf != NULL) {
106                                 fprintf(outf, "%s\n", buf);
107                                 fflush(outf);
108                         }
109                 }
110         }
111 }
112 
113 static void do_error(char *msg, bool errno_flag)
114 {
115         if (errno_flag)
116                 printf("ERROR: %s, errno: %d\n", msg, errno);
117         else
118                 printf("ERROR: %s\n", msg);
119         exit(1);
120 }
121 
122 static int prog_load(char *prog)
123 {
124         struct bpf_prog_load_attr prog_load_attr = {
125                 .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
126                 .file = prog,
127                 .expected_attach_type = BPF_CGROUP_INET_EGRESS,
128         };
129         int map_fd;
130         struct bpf_map *map;
131 
132         int ret = 0;
133 
134         if (access(prog, O_RDONLY) < 0) {
135                 printf("Error accessing file %s: %s\n", prog, strerror(errno));
136                 return 1;
137         }
138         if (bpf_prog_load_xattr(&prog_load_attr, &obj, &bpfprog_fd))
139                 ret = 1;
140         if (!ret) {
141                 map = bpf_object__find_map_by_name(obj, "queue_stats");
142                 map_fd = bpf_map__fd(map);
143                 if (map_fd < 0) {
144                         printf("Map not found: %s\n", strerror(map_fd));
145                         ret = 1;
146                 }
147         }
148 
149         if (ret) {
150                 printf("ERROR: bpf_prog_load_xattr failed for: %s\n", prog);
151                 printf("  Output from verifier:\n%s\n------\n", bpf_log_buf);
152                 ret = -1;
153         } else {
154                 ret = map_fd;
155         }
156 
157         return ret;
158 }
159 
160 static int run_bpf_prog(char *prog, int cg_id)
161 {
162         int map_fd;
163         int rc = 0;
164         int key = 0;
165         int cg1 = 0;
166         int type = BPF_CGROUP_INET_EGRESS;
167         char cg_dir[100];
168         struct hbm_queue_stats qstats = {0};
169 
170         sprintf(cg_dir, "/hbm%d", cg_id);
171         map_fd = prog_load(prog);
172         if (map_fd  == -1)
173                 return 1;
174 
175         if (setup_cgroup_environment()) {
176                 printf("ERROR: setting cgroup environment\n");
177                 goto err;
178         }
179         cg1 = create_and_get_cgroup(cg_dir);
180         if (!cg1) {
181                 printf("ERROR: create_and_get_cgroup\n");
182                 goto err;
183         }
184         if (join_cgroup(cg_dir)) {
185                 printf("ERROR: join_cgroup\n");
186                 goto err;
187         }
188 
189         qstats.rate = rate;
190         qstats.stats = stats_flag ? 1 : 0;
191         qstats.loopback = loopback_flag ? 1 : 0;
192         qstats.no_cn = no_cn_flag ? 1 : 0;
193         if (bpf_map_update_elem(map_fd, &key, &qstats, BPF_ANY)) {
194                 printf("ERROR: Could not update map element\n");
195                 goto err;
196         }
197 
198         if (!outFlag)
199                 type = BPF_CGROUP_INET_INGRESS;
200         if (bpf_prog_attach(bpfprog_fd, cg1, type, 0)) {
201                 printf("ERROR: bpf_prog_attach fails!\n");
202                 log_err("Attaching prog");
203                 goto err;
204         }
205 
206         if (work_conserving_flag) {
207                 struct timeval t0, t_last, t_new;
208                 FILE *fin;
209                 unsigned long long last_eth_tx_bytes, new_eth_tx_bytes;
210                 signed long long last_cg_tx_bytes, new_cg_tx_bytes;
211                 signed long long delta_time, delta_bytes, delta_rate;
212                 int delta_ms;
213 #define DELTA_RATE_CHECK 10000          /* in us */
214 #define RATE_THRESHOLD 9500000000       /* 9.5 Gbps */
215 
216                 bpf_map_lookup_elem(map_fd, &key, &qstats);
217                 if (gettimeofday(&t0, NULL) < 0)
218                         do_error("gettimeofday failed", true);
219                 t_last = t0;
220                 fin = fopen("/sys/class/net/eth0/statistics/tx_bytes", "r");
221                 if (fscanf(fin, "%llu", &last_eth_tx_bytes) != 1)
222                         do_error("fscanf fails", false);
223                 fclose(fin);
224                 last_cg_tx_bytes = qstats.bytes_total;
225                 while (true) {
226                         usleep(DELTA_RATE_CHECK);
227                         if (gettimeofday(&t_new, NULL) < 0)
228                                 do_error("gettimeofday failed", true);
229                         delta_ms = (t_new.tv_sec - t0.tv_sec) * 1000 +
230                                 (t_new.tv_usec - t0.tv_usec)/1000;
231                         if (delta_ms > dur * 1000)
232                                 break;
233                         delta_time = (t_new.tv_sec - t_last.tv_sec) * 1000000 +
234                                 (t_new.tv_usec - t_last.tv_usec);
235                         if (delta_time == 0)
236                                 continue;
237                         t_last = t_new;
238                         fin = fopen("/sys/class/net/eth0/statistics/tx_bytes",
239                                     "r");
240                         if (fscanf(fin, "%llu", &new_eth_tx_bytes) != 1)
241                                 do_error("fscanf fails", false);
242                         fclose(fin);
243                         printf("  new_eth_tx_bytes:%llu\n",
244                                new_eth_tx_bytes);
245                         bpf_map_lookup_elem(map_fd, &key, &qstats);
246                         new_cg_tx_bytes = qstats.bytes_total;
247                         delta_bytes = new_eth_tx_bytes - last_eth_tx_bytes;
248                         last_eth_tx_bytes = new_eth_tx_bytes;
249                         delta_rate = (delta_bytes * 8000000) / delta_time;
250                         printf("%5d - eth_rate:%.1fGbps cg_rate:%.3fGbps",
251                                delta_ms, delta_rate/1000000000.0,
252                                rate/1000.0);
253                         if (delta_rate < RATE_THRESHOLD) {
254                                 /* can increase cgroup rate limit, but first
255                                  * check if we are using the current limit.
256                                  * Currently increasing by 6.25%, unknown
257                                  * if that is the optimal rate.
258                                  */
259                                 int rate_diff100;
260 
261                                 delta_bytes = new_cg_tx_bytes -
262                                         last_cg_tx_bytes;
263                                 last_cg_tx_bytes = new_cg_tx_bytes;
264                                 delta_rate = (delta_bytes * 8000000) /
265                                         delta_time;
266                                 printf(" rate:%.3fGbps",
267                                        delta_rate/1000000000.0);
268                                 rate_diff100 = (((long long)rate)*1000000 -
269                                                      delta_rate) * 100 /
270                                         (((long long) rate) * 1000000);
271                                 printf("  rdiff:%d", rate_diff100);
272                                 if (rate_diff100  <= 3) {
273                                         rate += (rate >> 4);
274                                         if (rate > RATE_THRESHOLD / 1000000)
275                                                 rate = RATE_THRESHOLD / 1000000;
276                                         qstats.rate = rate;
277                                         printf(" INC\n");
278                                 } else {
279                                         printf("\n");
280                                 }
281                         } else {
282                                 /* Need to decrease cgroup rate limit.
283                                  * Currently decreasing by 12.5%, unknown
284                                  * if that is optimal
285                                  */
286                                 printf(" DEC\n");
287                                 rate -= (rate >> 3);
288                                 if (rate < minRate)
289                                         rate = minRate;
290                                 qstats.rate = rate;
291                         }
292                         if (bpf_map_update_elem(map_fd, &key, &qstats, BPF_ANY))
293                                 do_error("update map element fails", false);
294                 }
295         } else {
296                 sleep(dur);
297         }
298         // Get stats!
299         if (stats_flag && bpf_map_lookup_elem(map_fd, &key, &qstats)) {
300                 char fname[100];
301                 FILE *fout;
302 
303                 if (!outFlag)
304                         sprintf(fname, "hbm.%d.in", cg_id);
305                 else
306                         sprintf(fname, "hbm.%d.out", cg_id);
307                 fout = fopen(fname, "w");
308                 fprintf(fout, "id:%d\n", cg_id);
309                 fprintf(fout, "ERROR: Could not lookup queue_stats\n");
310         } else if (stats_flag && qstats.lastPacketTime >
311                    qstats.firstPacketTime) {
312                 long long delta_us = (qstats.lastPacketTime -
313                                       qstats.firstPacketTime)/1000;
314                 unsigned int rate_mbps = ((qstats.bytes_total -
315                                            qstats.bytes_dropped) * 8 /
316                                           delta_us);
317                 double percent_pkts, percent_bytes;
318                 char fname[100];
319                 FILE *fout;
320                 int k;
321                 static const char *returnValNames[] = {
322                         "DROP_PKT",
323                         "ALLOW_PKT",
324                         "DROP_PKT_CWR",
325                         "ALLOW_PKT_CWR"
326                 };
327 #define RET_VAL_COUNT 4
328 
329 // Future support of ingress
330 //              if (!outFlag)
331 //                      sprintf(fname, "hbm.%d.in", cg_id);
332 //              else
333                 sprintf(fname, "hbm.%d.out", cg_id);
334                 fout = fopen(fname, "w");
335                 fprintf(fout, "id:%d\n", cg_id);
336                 fprintf(fout, "rate_mbps:%d\n", rate_mbps);
337                 fprintf(fout, "duration:%.1f secs\n",
338                         (qstats.lastPacketTime - qstats.firstPacketTime) /
339                         1000000000.0);
340                 fprintf(fout, "packets:%d\n", (int)qstats.pkts_total);
341                 fprintf(fout, "bytes_MB:%d\n", (int)(qstats.bytes_total /
342                                                      1000000));
343                 fprintf(fout, "pkts_dropped:%d\n", (int)qstats.pkts_dropped);
344                 fprintf(fout, "bytes_dropped_MB:%d\n",
345                         (int)(qstats.bytes_dropped /
346                                                        1000000));
347                 // Marked Pkts and Bytes
348                 percent_pkts = (qstats.pkts_marked * 100.0) /
349                         (qstats.pkts_total + 1);
350                 percent_bytes = (qstats.bytes_marked * 100.0) /
351                         (qstats.bytes_total + 1);
352                 fprintf(fout, "pkts_marked_percent:%6.2f\n", percent_pkts);
353                 fprintf(fout, "bytes_marked_percent:%6.2f\n", percent_bytes);
354 
355                 // Dropped Pkts and Bytes
356                 percent_pkts = (qstats.pkts_dropped * 100.0) /
357                         (qstats.pkts_total + 1);
358                 percent_bytes = (qstats.bytes_dropped * 100.0) /
359                         (qstats.bytes_total + 1);
360                 fprintf(fout, "pkts_dropped_percent:%6.2f\n", percent_pkts);
361                 fprintf(fout, "bytes_dropped_percent:%6.2f\n", percent_bytes);
362 
363                 // ECN CE markings
364                 percent_pkts = (qstats.pkts_ecn_ce * 100.0) /
365                         (qstats.pkts_total + 1);
366                 fprintf(fout, "pkts_ecn_ce:%6.2f (%d)\n", percent_pkts,
367                         (int)qstats.pkts_ecn_ce);
368 
369                 // Average cwnd
370                 fprintf(fout, "avg cwnd:%d\n",
371                         (int)(qstats.sum_cwnd / (qstats.sum_cwnd_cnt + 1)));
372                 // Average rtt
373                 fprintf(fout, "avg rtt:%d\n",
374                         (int)(qstats.sum_rtt / (qstats.pkts_total + 1)));
375                 // Average credit
376                 if (edt_flag)
377                         fprintf(fout, "avg credit_ms:%.03f\n",
378                                 (qstats.sum_credit /
379                                  (qstats.pkts_total + 1.0)) / 1000000.0);
380                 else
381                         fprintf(fout, "avg credit:%d\n",
382                                 (int)(qstats.sum_credit /
383                                       (1500 * ((int)qstats.pkts_total ) + 1)));
384 
385                 // Return values stats
386                 for (k = 0; k < RET_VAL_COUNT; k++) {
387                         percent_pkts = (qstats.returnValCount[k] * 100.0) /
388                                 (qstats.pkts_total + 1);
389                         fprintf(fout, "%s:%6.2f (%d)\n", returnValNames[k],
390                                 percent_pkts, (int)qstats.returnValCount[k]);
391                 }
392                 fclose(fout);
393         }
394 
395         if (debugFlag)
396                 read_trace_pipe2();
397         return rc;
398 err:
399         rc = 1;
400 
401         if (cg1)
402                 close(cg1);
403         cleanup_cgroup_environment();
404 
405         return rc;
406 }
407 
408 static void Usage(void)
409 {
410         printf("This program loads a cgroup skb BPF program to enforce\n"
411                "cgroup output (egress) bandwidth limits.\n\n"
412                "USAGE: hbm [-o] [-d]  [-l] [-n <id>] [--no_cn] [-r <rate>]\n"
413                "           [-s] [-t <secs>] [-w] [-h] [prog]\n"
414                "  Where:\n"
415                "    -o         indicates egress direction (default)\n"
416                "    -d         print BPF trace debug buffer\n"
417                "    --edt      use fq's Earliest Departure Time\n"
418                "    -l         also limit flows using loopback\n"
419                "    -n <#>     to create cgroup \"/hbm#\" and attach prog\n"
420                "               Default is /hbm1\n"
421                "    --no_cn    disable CN notifications\n"
422                "    -r <rate>  Rate in Mbps\n"
423                "    -s         Update HBM stats\n"
424                "    -t <time>  Exit after specified seconds (default is 0)\n"
425                "    -w         Work conserving flag. cgroup can increase\n"
426                "               bandwidth beyond the rate limit specified\n"
427                "               while there is available bandwidth. Current\n"
428                "               implementation assumes there is only eth0\n"
429                "               but can be extended to support multiple NICs\n"
430                "    -h         print this info\n"
431                "    prog       BPF program file name. Name defaults to\n"
432                "                 hbm_out_kern.o\n");
433 }
434 
435 int main(int argc, char **argv)
436 {
437         char *prog = "hbm_out_kern.o";
438         int  k;
439         int cg_id = 1;
440         char *optstring = "iodln:r:st:wh";
441         struct option loptions[] = {
442                 {"no_cn", 0, NULL, 1},
443                 {"edt", 0, NULL, 2},
444                 {NULL, 0, NULL, 0}
445         };
446 
447         while ((k = getopt_long(argc, argv, optstring, loptions, NULL)) != -1) {
448                 switch (k) {
449                 case 1:
450                         no_cn_flag = true;
451                         break;
452                 case 2:
453                         prog = "hbm_edt_kern.o";
454                         edt_flag = true;
455                         break;
456                 case'o':
457                         break;
458                 case 'd':
459                         debugFlag = true;
460                         break;
461                 case 'l':
462                         loopback_flag = true;
463                         break;
464                 case 'n':
465                         cg_id = atoi(optarg);
466                         break;
467                 case 'r':
468                         minRate = atoi(optarg) * 1.024;
469                         rate = minRate;
470                         break;
471                 case 's':
472                         stats_flag = true;
473                         break;
474                 case 't':
475                         dur = atoi(optarg);
476                         break;
477                 case 'w':
478                         work_conserving_flag = true;
479                         break;
480                 case '?':
481                         if (optopt == 'n' || optopt == 'r' || optopt == 't')
482                                 fprintf(stderr,
483                                         "Option -%c requires an argument.\n\n",
484                                         optopt);
485                 case 'h':
486                         // fallthrough
487                 default:
488                         Usage();
489                         return 0;
490                 }
491         }
492 
493         if (optind < argc)
494                 prog = argv[optind];
495         printf("HBM prog: %s\n", prog != NULL ? prog : "NULL");
496 
497         return run_bpf_prog(prog, cg_id);
498 }
499 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp