arm64: dts: qcom: sm8550: add TRNG node
[linux-modified.git] / include / trace / events / handshake.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #undef TRACE_SYSTEM
3 #define TRACE_SYSTEM handshake
4
5 #if !defined(_TRACE_HANDSHAKE_H) || defined(TRACE_HEADER_MULTI_READ)
6 #define _TRACE_HANDSHAKE_H
7
8 #include <linux/net.h>
9 #include <net/tls_prot.h>
10 #include <linux/tracepoint.h>
11 #include <trace/events/net_probe_common.h>
12
13 #define TLS_RECORD_TYPE_LIST \
14         record_type(CHANGE_CIPHER_SPEC) \
15         record_type(ALERT) \
16         record_type(HANDSHAKE) \
17         record_type(DATA) \
18         record_type(HEARTBEAT) \
19         record_type(TLS12_CID) \
20         record_type_end(ACK)
21
22 #undef record_type
23 #undef record_type_end
24 #define record_type(x)          TRACE_DEFINE_ENUM(TLS_RECORD_TYPE_##x);
25 #define record_type_end(x)      TRACE_DEFINE_ENUM(TLS_RECORD_TYPE_##x);
26
27 TLS_RECORD_TYPE_LIST
28
29 #undef record_type
30 #undef record_type_end
31 #define record_type(x)          { TLS_RECORD_TYPE_##x, #x },
32 #define record_type_end(x)      { TLS_RECORD_TYPE_##x, #x }
33
34 #define show_tls_content_type(type) \
35         __print_symbolic(type, TLS_RECORD_TYPE_LIST)
36
37 TRACE_DEFINE_ENUM(TLS_ALERT_LEVEL_WARNING);
38 TRACE_DEFINE_ENUM(TLS_ALERT_LEVEL_FATAL);
39
40 #define show_tls_alert_level(level) \
41         __print_symbolic(level, \
42                 { TLS_ALERT_LEVEL_WARNING,      "Warning" }, \
43                 { TLS_ALERT_LEVEL_FATAL,        "Fatal" })
44
45 #define TLS_ALERT_DESCRIPTION_LIST \
46         alert_description(CLOSE_NOTIFY) \
47         alert_description(UNEXPECTED_MESSAGE) \
48         alert_description(BAD_RECORD_MAC) \
49         alert_description(RECORD_OVERFLOW) \
50         alert_description(HANDSHAKE_FAILURE) \
51         alert_description(BAD_CERTIFICATE) \
52         alert_description(UNSUPPORTED_CERTIFICATE) \
53         alert_description(CERTIFICATE_REVOKED) \
54         alert_description(CERTIFICATE_EXPIRED) \
55         alert_description(CERTIFICATE_UNKNOWN) \
56         alert_description(ILLEGAL_PARAMETER) \
57         alert_description(UNKNOWN_CA) \
58         alert_description(ACCESS_DENIED) \
59         alert_description(DECODE_ERROR) \
60         alert_description(DECRYPT_ERROR) \
61         alert_description(TOO_MANY_CIDS_REQUESTED) \
62         alert_description(PROTOCOL_VERSION) \
63         alert_description(INSUFFICIENT_SECURITY) \
64         alert_description(INTERNAL_ERROR) \
65         alert_description(INAPPROPRIATE_FALLBACK) \
66         alert_description(USER_CANCELED) \
67         alert_description(MISSING_EXTENSION) \
68         alert_description(UNSUPPORTED_EXTENSION) \
69         alert_description(UNRECOGNIZED_NAME) \
70         alert_description(BAD_CERTIFICATE_STATUS_RESPONSE) \
71         alert_description(UNKNOWN_PSK_IDENTITY) \
72         alert_description(CERTIFICATE_REQUIRED) \
73         alert_description_end(NO_APPLICATION_PROTOCOL)
74
75 #undef alert_description
76 #undef alert_description_end
77 #define alert_description(x)            TRACE_DEFINE_ENUM(TLS_ALERT_DESC_##x);
78 #define alert_description_end(x)        TRACE_DEFINE_ENUM(TLS_ALERT_DESC_##x);
79
80 TLS_ALERT_DESCRIPTION_LIST
81
82 #undef alert_description
83 #undef alert_description_end
84 #define alert_description(x)            { TLS_ALERT_DESC_##x, #x },
85 #define alert_description_end(x)        { TLS_ALERT_DESC_##x, #x }
86
87 #define show_tls_alert_description(desc) \
88         __print_symbolic(desc, TLS_ALERT_DESCRIPTION_LIST)
89
90 DECLARE_EVENT_CLASS(handshake_event_class,
91         TP_PROTO(
92                 const struct net *net,
93                 const struct handshake_req *req,
94                 const struct sock *sk
95         ),
96         TP_ARGS(net, req, sk),
97         TP_STRUCT__entry(
98                 __field(const void *, req)
99                 __field(const void *, sk)
100                 __field(unsigned int, netns_ino)
101         ),
102         TP_fast_assign(
103                 __entry->req = req;
104                 __entry->sk = sk;
105                 __entry->netns_ino = net->ns.inum;
106         ),
107         TP_printk("req=%p sk=%p",
108                 __entry->req, __entry->sk
109         )
110 );
111 #define DEFINE_HANDSHAKE_EVENT(name)                            \
112         DEFINE_EVENT(handshake_event_class, name,               \
113                 TP_PROTO(                                       \
114                         const struct net *net,                  \
115                         const struct handshake_req *req,        \
116                         const struct sock *sk                   \
117                 ),                                              \
118                 TP_ARGS(net, req, sk))
119
120 DECLARE_EVENT_CLASS(handshake_fd_class,
121         TP_PROTO(
122                 const struct net *net,
123                 const struct handshake_req *req,
124                 const struct sock *sk,
125                 int fd
126         ),
127         TP_ARGS(net, req, sk, fd),
128         TP_STRUCT__entry(
129                 __field(const void *, req)
130                 __field(const void *, sk)
131                 __field(int, fd)
132                 __field(unsigned int, netns_ino)
133         ),
134         TP_fast_assign(
135                 __entry->req = req;
136                 __entry->sk = req->hr_sk;
137                 __entry->fd = fd;
138                 __entry->netns_ino = net->ns.inum;
139         ),
140         TP_printk("req=%p sk=%p fd=%d",
141                 __entry->req, __entry->sk, __entry->fd
142         )
143 );
144 #define DEFINE_HANDSHAKE_FD_EVENT(name)                         \
145         DEFINE_EVENT(handshake_fd_class, name,                  \
146                 TP_PROTO(                                       \
147                         const struct net *net,                  \
148                         const struct handshake_req *req,        \
149                         const struct sock *sk,                  \
150                         int fd                                  \
151                 ),                                              \
152                 TP_ARGS(net, req, sk, fd))
153
154 DECLARE_EVENT_CLASS(handshake_error_class,
155         TP_PROTO(
156                 const struct net *net,
157                 const struct handshake_req *req,
158                 const struct sock *sk,
159                 int err
160         ),
161         TP_ARGS(net, req, sk, err),
162         TP_STRUCT__entry(
163                 __field(const void *, req)
164                 __field(const void *, sk)
165                 __field(int, err)
166                 __field(unsigned int, netns_ino)
167         ),
168         TP_fast_assign(
169                 __entry->req = req;
170                 __entry->sk = sk;
171                 __entry->err = err;
172                 __entry->netns_ino = net->ns.inum;
173         ),
174         TP_printk("req=%p sk=%p err=%d",
175                 __entry->req, __entry->sk, __entry->err
176         )
177 );
178 #define DEFINE_HANDSHAKE_ERROR(name)                            \
179         DEFINE_EVENT(handshake_error_class, name,               \
180                 TP_PROTO(                                       \
181                         const struct net *net,                  \
182                         const struct handshake_req *req,        \
183                         const struct sock *sk,                  \
184                         int err                                 \
185                 ),                                              \
186                 TP_ARGS(net, req, sk, err))
187
188 DECLARE_EVENT_CLASS(handshake_alert_class,
189         TP_PROTO(
190                 const struct sock *sk,
191                 unsigned char level,
192                 unsigned char description
193         ),
194         TP_ARGS(sk, level, description),
195         TP_STRUCT__entry(
196                 /* sockaddr_in6 is always bigger than sockaddr_in */
197                 __array(__u8, saddr, sizeof(struct sockaddr_in6))
198                 __array(__u8, daddr, sizeof(struct sockaddr_in6))
199                 __field(unsigned int, netns_ino)
200                 __field(unsigned long, level)
201                 __field(unsigned long, description)
202         ),
203         TP_fast_assign(
204                 const struct inet_sock *inet = inet_sk(sk);
205
206                 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
207                 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
208                 TP_STORE_ADDR_PORTS(__entry, inet, sk);
209
210                 __entry->netns_ino = sock_net(sk)->ns.inum;
211                 __entry->level = level;
212                 __entry->description = description;
213         ),
214         TP_printk("src=%pISpc dest=%pISpc %s: %s",
215                 __entry->saddr, __entry->daddr,
216                 show_tls_alert_level(__entry->level),
217                 show_tls_alert_description(__entry->description)
218         )
219 );
220 #define DEFINE_HANDSHAKE_ALERT(name)                            \
221         DEFINE_EVENT(handshake_alert_class, name,               \
222                 TP_PROTO(                                       \
223                         const struct sock *sk,                  \
224                         unsigned char level,                    \
225                         unsigned char description               \
226                 ),                                              \
227                 TP_ARGS(sk, level, description))
228
229
230 /*
231  * Request lifetime events
232  */
233
234 DEFINE_HANDSHAKE_EVENT(handshake_submit);
235 DEFINE_HANDSHAKE_ERROR(handshake_submit_err);
236 DEFINE_HANDSHAKE_EVENT(handshake_cancel);
237 DEFINE_HANDSHAKE_EVENT(handshake_cancel_none);
238 DEFINE_HANDSHAKE_EVENT(handshake_cancel_busy);
239 DEFINE_HANDSHAKE_EVENT(handshake_destruct);
240
241
242 TRACE_EVENT(handshake_complete,
243         TP_PROTO(
244                 const struct net *net,
245                 const struct handshake_req *req,
246                 const struct sock *sk,
247                 int status
248         ),
249         TP_ARGS(net, req, sk, status),
250         TP_STRUCT__entry(
251                 __field(const void *, req)
252                 __field(const void *, sk)
253                 __field(int, status)
254                 __field(unsigned int, netns_ino)
255         ),
256         TP_fast_assign(
257                 __entry->req = req;
258                 __entry->sk = sk;
259                 __entry->status = status;
260                 __entry->netns_ino = net->ns.inum;
261         ),
262         TP_printk("req=%p sk=%p status=%d",
263                 __entry->req, __entry->sk, __entry->status
264         )
265 );
266
267 /*
268  * Netlink events
269  */
270
271 DEFINE_HANDSHAKE_ERROR(handshake_notify_err);
272 DEFINE_HANDSHAKE_FD_EVENT(handshake_cmd_accept);
273 DEFINE_HANDSHAKE_ERROR(handshake_cmd_accept_err);
274 DEFINE_HANDSHAKE_FD_EVENT(handshake_cmd_done);
275 DEFINE_HANDSHAKE_ERROR(handshake_cmd_done_err);
276
277 /*
278  * TLS Record events
279  */
280
281 TRACE_EVENT(tls_contenttype,
282         TP_PROTO(
283                 const struct sock *sk,
284                 unsigned char type
285         ),
286         TP_ARGS(sk, type),
287         TP_STRUCT__entry(
288                 /* sockaddr_in6 is always bigger than sockaddr_in */
289                 __array(__u8, saddr, sizeof(struct sockaddr_in6))
290                 __array(__u8, daddr, sizeof(struct sockaddr_in6))
291                 __field(unsigned int, netns_ino)
292                 __field(unsigned long, type)
293         ),
294         TP_fast_assign(
295                 const struct inet_sock *inet = inet_sk(sk);
296
297                 memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
298                 memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
299                 TP_STORE_ADDR_PORTS(__entry, inet, sk);
300
301                 __entry->netns_ino = sock_net(sk)->ns.inum;
302                 __entry->type = type;
303         ),
304         TP_printk("src=%pISpc dest=%pISpc %s",
305                 __entry->saddr, __entry->daddr,
306                 show_tls_content_type(__entry->type)
307         )
308 );
309
310 /*
311  * TLS Alert events
312  */
313
314 DEFINE_HANDSHAKE_ALERT(tls_alert_send);
315 DEFINE_HANDSHAKE_ALERT(tls_alert_recv);
316
317 #endif /* _TRACE_HANDSHAKE_H */
318
319 #include <trace/define_trace.h>