?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ext4: fix some nonstandard indentation in extents.c
[linux/fpc-iii.git] / samples / bpf / hbm.c
blob829b68d8768770b053e2695d9dd4c4a9a27c9001
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.h"
54 #include "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 }
Linux with added FPC-III support