net/bnxt: add Truflow flush-timer to alloc table scope
[dpdk.git] / drivers / net / tap / tap_netlink.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright 2017 6WIND S.A.
3  * Copyright 2017 Mellanox Technologies, Ltd
4  */
5
6 #include <errno.h>
7 #include <inttypes.h>
8 #include <linux/netlink.h>
9 #include <string.h>
10 #include <sys/socket.h>
11 #include <unistd.h>
12
13 #include <rte_malloc.h>
14 #include <tap_netlink.h>
15 #include <rte_random.h>
16 #include "tap_log.h"
17
18 /* Must be quite large to support dumping a huge list of QDISC or filters. */
19 #define BUF_SIZE (32 * 1024) /* Size of the buffer to receive kernel messages */
20 #define SNDBUF_SIZE 32768 /* Send buffer size for the netlink socket */
21 #define RCVBUF_SIZE 32768 /* Receive buffer size for the netlink socket */
22
23 struct nested_tail {
24         struct rtattr *tail;
25         struct nested_tail *prev;
26 };
27
28 /**
29  * Initialize a netlink socket for communicating with the kernel.
30  *
31  * @param nl_groups
32  *   Set it to a netlink group value (e.g. RTMGRP_LINK) to receive messages for
33  *   specific netlink multicast groups. Otherwise, no subscription will be made.
34  *
35  * @return
36  *   netlink socket file descriptor on success, -1 otherwise.
37  */
38 int
39 tap_nl_init(uint32_t nl_groups)
40 {
41         int fd, sndbuf_size = SNDBUF_SIZE, rcvbuf_size = RCVBUF_SIZE;
42         struct sockaddr_nl local = {
43                 .nl_family = AF_NETLINK,
44                 .nl_groups = nl_groups,
45         };
46
47         fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
48         if (fd < 0) {
49                 TAP_LOG(ERR, "Unable to create a netlink socket");
50                 return -1;
51         }
52         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sndbuf_size, sizeof(int))) {
53                 TAP_LOG(ERR, "Unable to set socket buffer send size");
54                 close(fd);
55                 return -1;
56         }
57         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf_size, sizeof(int))) {
58                 TAP_LOG(ERR, "Unable to set socket buffer receive size");
59                 close(fd);
60                 return -1;
61         }
62         if (bind(fd, (struct sockaddr *)&local, sizeof(local)) < 0) {
63                 TAP_LOG(ERR, "Unable to bind to the netlink socket");
64                 close(fd);
65                 return -1;
66         }
67         return fd;
68 }
69
70 /**
71  * Clean up a netlink socket once all communicating with the kernel is finished.
72  *
73  * @param[in] nlsk_fd
74  *   The netlink socket file descriptor used for communication.
75  *
76  * @return
77  *   0 on success, -1 otherwise.
78  */
79 int
80 tap_nl_final(int nlsk_fd)
81 {
82         if (close(nlsk_fd)) {
83                 TAP_LOG(ERR, "Failed to close netlink socket: %s (%d)",
84                         strerror(errno), errno);
85                 return -1;
86         }
87         return 0;
88 }
89
90 /**
91  * Send a message to the kernel on the netlink socket.
92  *
93  * @param[in] nlsk_fd
94  *   The netlink socket file descriptor used for communication.
95  * @param[in] nh
96  *   The netlink message send to the kernel.
97  *
98  * @return
99  *   the number of sent bytes on success, -1 otherwise.
100  */
101 int
102 tap_nl_send(int nlsk_fd, struct nlmsghdr *nh)
103 {
104         /* man 7 netlink EXAMPLE */
105         struct sockaddr_nl sa = {
106                 .nl_family = AF_NETLINK,
107         };
108         struct iovec iov = {
109                 .iov_base = nh,
110                 .iov_len = nh->nlmsg_len,
111         };
112         struct msghdr msg = {
113                 .msg_name = &sa,
114                 .msg_namelen = sizeof(sa),
115                 .msg_iov = &iov,
116                 .msg_iovlen = 1,
117         };
118         int send_bytes;
119
120         nh->nlmsg_pid = 0; /* communication with the kernel uses pid 0 */
121         nh->nlmsg_seq = (uint32_t)rte_rand();
122         send_bytes = sendmsg(nlsk_fd, &msg, 0);
123         if (send_bytes < 0) {
124                 TAP_LOG(ERR, "Failed to send netlink message: %s (%d)",
125                         strerror(errno), errno);
126                 return -1;
127         }
128         return send_bytes;
129 }
130
131 /**
132  * Check that the kernel sends an appropriate ACK in response
133  * to an tap_nl_send().
134  *
135  * @param[in] nlsk_fd
136  *   The netlink socket file descriptor used for communication.
137  *
138  * @return
139  *   0 on success, -1 otherwise with errno set.
140  */
141 int
142 tap_nl_recv_ack(int nlsk_fd)
143 {
144         return tap_nl_recv(nlsk_fd, NULL, NULL);
145 }
146
147 /**
148  * Receive a message from the kernel on the netlink socket, following an
149  * tap_nl_send().
150  *
151  * @param[in] nlsk_fd
152  *   The netlink socket file descriptor used for communication.
153  * @param[in] cb
154  *   The callback function to call for each netlink message received.
155  * @param[in, out] arg
156  *   Custom arguments for the callback.
157  *
158  * @return
159  *   0 on success, -1 otherwise with errno set.
160  */
161 int
162 tap_nl_recv(int nlsk_fd, int (*cb)(struct nlmsghdr *, void *arg), void *arg)
163 {
164         /* man 7 netlink EXAMPLE */
165         struct sockaddr_nl sa;
166         char buf[BUF_SIZE];
167         struct iovec iov = {
168                 .iov_base = buf,
169                 .iov_len = sizeof(buf),
170         };
171         struct msghdr msg = {
172                 .msg_name = &sa,
173                 .msg_namelen = sizeof(sa),
174                 .msg_iov = &iov,
175                 /* One message at a time */
176                 .msg_iovlen = 1,
177         };
178         int multipart = 0;
179         int ret = 0;
180
181         do {
182                 struct nlmsghdr *nh;
183                 int recv_bytes = 0;
184
185                 recv_bytes = recvmsg(nlsk_fd, &msg, 0);
186                 if (recv_bytes < 0)
187                         return -1;
188                 for (nh = (struct nlmsghdr *)buf;
189                      NLMSG_OK(nh, (unsigned int)recv_bytes);
190                      nh = NLMSG_NEXT(nh, recv_bytes)) {
191                         if (nh->nlmsg_type == NLMSG_ERROR) {
192                                 struct nlmsgerr *err_data = NLMSG_DATA(nh);
193
194                                 if (err_data->error < 0) {
195                                         errno = -err_data->error;
196                                         return -1;
197                                 }
198                                 /* Ack message. */
199                                 return 0;
200                         }
201                         /* Multi-part msgs and their trailing DONE message. */
202                         if (nh->nlmsg_flags & NLM_F_MULTI) {
203                                 if (nh->nlmsg_type == NLMSG_DONE)
204                                         return 0;
205                                 multipart = 1;
206                         }
207                         if (cb)
208                                 ret = cb(nh, arg);
209                 }
210         } while (multipart);
211         return ret;
212 }
213
214 /**
215  * Append a netlink attribute to a message.
216  *
217  * @param[in, out] nh
218  *   The netlink message to parse, received from the kernel.
219  * @param[in] type
220  *   The type of attribute to append.
221  * @param[in] data_len
222  *   The length of the data to append.
223  * @param[in] data
224  *   The data to append.
225  */
226 void
227 tap_nlattr_add(struct nlmsghdr *nh, unsigned short type,
228            unsigned int data_len, const void *data)
229 {
230         /* see man 3 rtnetlink */
231         struct rtattr *rta;
232
233         rta = (struct rtattr *)NLMSG_TAIL(nh);
234         rta->rta_len = RTA_LENGTH(data_len);
235         rta->rta_type = type;
236         memcpy(RTA_DATA(rta), data, data_len);
237         nh->nlmsg_len = NLMSG_ALIGN(nh->nlmsg_len) + RTA_ALIGN(rta->rta_len);
238 }
239
240 /**
241  * Append a uint8_t netlink attribute to a message.
242  *
243  * @param[in, out] nh
244  *   The netlink message to parse, received from the kernel.
245  * @param[in] type
246  *   The type of attribute to append.
247  * @param[in] data
248  *   The data to append.
249  */
250 void
251 tap_nlattr_add8(struct nlmsghdr *nh, unsigned short type, uint8_t data)
252 {
253         tap_nlattr_add(nh, type, sizeof(uint8_t), &data);
254 }
255
256 /**
257  * Append a uint16_t netlink attribute to a message.
258  *
259  * @param[in, out] nh
260  *   The netlink message to parse, received from the kernel.
261  * @param[in] type
262  *   The type of attribute to append.
263  * @param[in] data
264  *   The data to append.
265  */
266 void
267 tap_nlattr_add16(struct nlmsghdr *nh, unsigned short type, uint16_t data)
268 {
269         tap_nlattr_add(nh, type, sizeof(uint16_t), &data);
270 }
271
272 /**
273  * Append a uint16_t netlink attribute to a message.
274  *
275  * @param[in, out] nh
276  *   The netlink message to parse, received from the kernel.
277  * @param[in] type
278  *   The type of attribute to append.
279  * @param[in] data
280  *   The data to append.
281  */
282 void
283 tap_nlattr_add32(struct nlmsghdr *nh, unsigned short type, uint32_t data)
284 {
285         tap_nlattr_add(nh, type, sizeof(uint32_t), &data);
286 }
287
288 /**
289  * Start a nested netlink attribute.
290  * It must be followed later by a call to tap_nlattr_nested_finish().
291  *
292  * @param[in, out] msg
293  *   The netlink message where to edit the nested_tails metadata.
294  * @param[in] type
295  *   The nested attribute type to append.
296  *
297  * @return
298  *   -1 if adding a nested netlink attribute failed, 0 otherwise.
299  */
300 int
301 tap_nlattr_nested_start(struct nlmsg *msg, uint16_t type)
302 {
303         struct nested_tail *tail;
304
305         tail = rte_zmalloc(NULL, sizeof(struct nested_tail), 0);
306         if (!tail) {
307                 TAP_LOG(ERR,
308                         "Couldn't allocate memory for nested netlink attribute");
309                 return -1;
310         }
311
312         tail->tail = (struct rtattr *)NLMSG_TAIL(&msg->nh);
313
314         tap_nlattr_add(&msg->nh, type, 0, NULL);
315
316         tail->prev = msg->nested_tails;
317
318         msg->nested_tails = tail;
319
320         return 0;
321 }
322
323 /**
324  * End a nested netlink attribute.
325  * It follows a call to tap_nlattr_nested_start().
326  * In effect, it will modify the nested attribute length to include every bytes
327  * from the nested attribute start, up to here.
328  *
329  * @param[in, out] msg
330  *   The netlink message where to edit the nested_tails metadata.
331  */
332 void
333 tap_nlattr_nested_finish(struct nlmsg *msg)
334 {
335         struct nested_tail *tail = msg->nested_tails;
336
337         tail->tail->rta_len = (char *)NLMSG_TAIL(&msg->nh) - (char *)tail->tail;
338
339         if (tail->prev)
340                 msg->nested_tails = tail->prev;
341
342         rte_free(tail);
343 }