1 /*
2 * Copyright (c) 2017 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 #define KBUILD_MODNAME "foo"
9 #include "vmlinux.h"
10 #include <linux/version.h>
11 #include <bpf/bpf_helpers.h>
12 #include <bpf/bpf_tracing.h>
13 #include <bpf/bpf_core_read.h>
14
15 #define MAX_NR_PORTS 65536
16
17 #define EINVAL 22
18 #define ENOENT 2
19
20 /* map #0 */
21 struct inner_a {
22 __uint(type, BPF_MAP_TYPE_ARRAY);
23 __type(key, u32);
24 __type(value, int);
25 __uint(max_entries, MAX_NR_PORTS);
26 } port_a SEC(".maps");
27
28 /* map #1 */
29 struct inner_h {
30 __uint(type, BPF_MAP_TYPE_HASH);
31 __type(key, u32);
32 __type(value, int);
33 __uint(max_entries, 1);
34 } port_h SEC(".maps");
35
36 /* map #2 */
37 struct {
38 __uint(type, BPF_MAP_TYPE_HASH);
39 __type(key, u32);
40 __type(value, int);
41 __uint(max_entries, 1);
42 } reg_result_h SEC(".maps");
43
44 /* map #3 */
45 struct {
46 __uint(type, BPF_MAP_TYPE_HASH);
47 __type(key, u32);
48 __type(value, int);
49 __uint(max_entries, 1);
50 } inline_result_h SEC(".maps");
51
52 /* map #4 */ /* Test case #0 */
53 struct {
54 __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
55 __uint(max_entries, MAX_NR_PORTS);
56 __uint(key_size, sizeof(u32));
57 __array(values, struct inner_a); /* use inner_a as inner map */
58 } a_of_port_a SEC(".maps");
59
60 /* map #5 */ /* Test case #1 */
61 struct {
62 __uint(type, BPF_MAP_TYPE_HASH_OF_MAPS);
63 __uint(max_entries, 1);
64 __uint(key_size, sizeof(u32));
65 __array(values, struct inner_a); /* use inner_a as inner map */
66 } h_of_port_a SEC(".maps");
67
68 /* map #6 */ /* Test case #2 */
69 struct {
70 __uint(type, BPF_MAP_TYPE_HASH_OF_MAPS);
71 __uint(max_entries, 1);
72 __uint(key_size, sizeof(u32));
73 __array(values, struct inner_h); /* use inner_h as inner map */
74 } h_of_port_h SEC(".maps");
75
76 static __always_inline int do_reg_lookup(void *inner_map, u32 port)
77 {
78 int *result;
79
80 result = bpf_map_lookup_elem(inner_map, &port);
81 return result ? *result : -ENOENT;
82 }
83
84 static __always_inline int do_inline_array_lookup(void *inner_map, u32 port)
85 {
86 int *result;
87
88 if (inner_map != &port_a)
89 return -EINVAL;
90
91 result = bpf_map_lookup_elem(&port_a, &port);
92 return result ? *result : -ENOENT;
93 }
94
95 static __always_inline int do_inline_hash_lookup(void *inner_map, u32 port)
96 {
97 int *result;
98
99 if (inner_map != &port_h)
100 return -EINVAL;
101
102 result = bpf_map_lookup_elem(&port_h, &port);
103 return result ? *result : -ENOENT;
104 }
105
106 SEC("ksyscall/connect")
107 int BPF_KSYSCALL(trace_sys_connect, unsigned int fd, struct sockaddr_in6 *in6, int addrlen)
108 {
109 u16 test_case, port, dst6[8];
110 int ret, inline_ret, ret_key = 0;
111 u32 port_key;
112 void *outer_map, *inner_map;
113 bool inline_hash = false;
114
115 if (addrlen != sizeof(*in6))
116 return 0;
117
118 ret = bpf_probe_read_user(dst6, sizeof(dst6), &in6->sin6_addr);
119 if (ret) {
120 inline_ret = ret;
121 goto done;
122 }
123
124 if (dst6[0] != 0xdead || dst6[1] != 0xbeef)
125 return 0;
126
127 test_case = dst6[7];
128
129 ret = bpf_probe_read_user(&port, sizeof(port), &in6->sin6_port);
130 if (ret) {
131 inline_ret = ret;
132 goto done;
133 }
134
135 port_key = port;
136
137 ret = -ENOENT;
138 if (test_case == 0) {
139 outer_map = &a_of_port_a;
140 } else if (test_case == 1) {
141 outer_map = &h_of_port_a;
142 } else if (test_case == 2) {
143 outer_map = &h_of_port_h;
144 } else {
145 ret = __LINE__;
146 inline_ret = ret;
147 goto done;
148 }
149
150 inner_map = bpf_map_lookup_elem(outer_map, &port_key);
151 if (!inner_map) {
152 ret = __LINE__;
153 inline_ret = ret;
154 goto done;
155 }
156
157 ret = do_reg_lookup(inner_map, port_key);
158
159 if (test_case == 0 || test_case == 1)
160 inline_ret = do_inline_array_lookup(inner_map, port_key);
161 else
162 inline_ret = do_inline_hash_lookup(inner_map, port_key);
163
164 done:
165 bpf_map_update_elem(®_result_h, &ret_key, &ret, BPF_ANY);
166 bpf_map_update_elem(&inline_result_h, &ret_key, &inline_ret, BPF_ANY);
167
168 return 0;
169 }
170
171 char _license[] SEC("license") = "GPL";
172 u32 _version SEC("version") = LINUX_VERSION_CODE;
173
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.