@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 1,883 lines 56.1 KB
Raw
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, see <http://www.gnu.org/licenses/>.
14 */
15
16 #include "qemu/osdep.h"
17
18 #include <sys/signalfd.h>
19 #include <linux/unistd.h>
20 #include <linux/audit.h>
21 #include <sys/inotify.h>
22 #include <linux/netlink.h>
23 #ifdef CONFIG_RTNETLINK
24 #include <linux/rtnetlink.h>
25 #include <linux/if_bridge.h>
26 #include <linux/neighbour.h>
27 #endif
28 #include "qemu.h"
29 #include "user-internals.h"
30 #include "fd-trans.h"
31 #include "signal-common.h"
32
33 #define NDM_RTA(r) ((struct rtattr*)(((char*)(r)) + \
34 NLMSG_ALIGN(sizeof(struct ndmsg))))
35
36 enum {
37 QEMU_IFA_UNSPEC,
38 QEMU_IFA_ADDRESS,
39 QEMU_IFA_LOCAL,
40 QEMU_IFA_LABEL,
41 QEMU_IFA_BROADCAST,
42 QEMU_IFA_ANYCAST,
43 QEMU_IFA_CACHEINFO,
44 QEMU_IFA_MULTICAST,
45 QEMU_IFA_FLAGS,
46 QEMU_IFA_RT_PRIORITY,
47 QEMU_IFA_TARGET_NETNSID,
48 QEMU_IFA_PROTO,
49 QEMU__IFA__MAX,
50 };
51
52 enum {
53 QEMU_IFLA_BR_UNSPEC,
54 QEMU_IFLA_BR_FORWARD_DELAY,
55 QEMU_IFLA_BR_HELLO_TIME,
56 QEMU_IFLA_BR_MAX_AGE,
57 QEMU_IFLA_BR_AGEING_TIME,
58 QEMU_IFLA_BR_STP_STATE,
59 QEMU_IFLA_BR_PRIORITY,
60 QEMU_IFLA_BR_VLAN_FILTERING,
61 QEMU_IFLA_BR_VLAN_PROTOCOL,
62 QEMU_IFLA_BR_GROUP_FWD_MASK,
63 QEMU_IFLA_BR_ROOT_ID,
64 QEMU_IFLA_BR_BRIDGE_ID,
65 QEMU_IFLA_BR_ROOT_PORT,
66 QEMU_IFLA_BR_ROOT_PATH_COST,
67 QEMU_IFLA_BR_TOPOLOGY_CHANGE,
68 QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
69 QEMU_IFLA_BR_HELLO_TIMER,
70 QEMU_IFLA_BR_TCN_TIMER,
71 QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER,
72 QEMU_IFLA_BR_GC_TIMER,
73 QEMU_IFLA_BR_GROUP_ADDR,
74 QEMU_IFLA_BR_FDB_FLUSH,
75 QEMU_IFLA_BR_MCAST_ROUTER,
76 QEMU_IFLA_BR_MCAST_SNOOPING,
77 QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR,
78 QEMU_IFLA_BR_MCAST_QUERIER,
79 QEMU_IFLA_BR_MCAST_HASH_ELASTICITY,
80 QEMU_IFLA_BR_MCAST_HASH_MAX,
81 QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT,
82 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT,
83 QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL,
84 QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL,
85 QEMU_IFLA_BR_MCAST_QUERIER_INTVL,
86 QEMU_IFLA_BR_MCAST_QUERY_INTVL,
87 QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL,
88 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL,
89 QEMU_IFLA_BR_NF_CALL_IPTABLES,
90 QEMU_IFLA_BR_NF_CALL_IP6TABLES,
91 QEMU_IFLA_BR_NF_CALL_ARPTABLES,
92 QEMU_IFLA_BR_VLAN_DEFAULT_PVID,
93 QEMU_IFLA_BR_PAD,
94 QEMU_IFLA_BR_VLAN_STATS_ENABLED,
95 QEMU_IFLA_BR_MCAST_STATS_ENABLED,
96 QEMU_IFLA_BR_MCAST_IGMP_VERSION,
97 QEMU_IFLA_BR_MCAST_MLD_VERSION,
98 QEMU_IFLA_BR_VLAN_STATS_PER_PORT,
99 QEMU_IFLA_BR_MULTI_BOOLOPT,
100 QEMU___IFLA_BR_MAX,
101 };
102
103 enum {
104 QEMU_IFLA_UNSPEC,
105 QEMU_IFLA_ADDRESS,
106 QEMU_IFLA_BROADCAST,
107 QEMU_IFLA_IFNAME,
108 QEMU_IFLA_MTU,
109 QEMU_IFLA_LINK,
110 QEMU_IFLA_QDISC,
111 QEMU_IFLA_STATS,
112 QEMU_IFLA_COST,
113 QEMU_IFLA_PRIORITY,
114 QEMU_IFLA_MASTER,
115 QEMU_IFLA_WIRELESS,
116 QEMU_IFLA_PROTINFO,
117 QEMU_IFLA_TXQLEN,
118 QEMU_IFLA_MAP,
119 QEMU_IFLA_WEIGHT,
120 QEMU_IFLA_OPERSTATE,
121 QEMU_IFLA_LINKMODE,
122 QEMU_IFLA_LINKINFO,
123 QEMU_IFLA_NET_NS_PID,
124 QEMU_IFLA_IFALIAS,
125 QEMU_IFLA_NUM_VF,
126 QEMU_IFLA_VFINFO_LIST,
127 QEMU_IFLA_STATS64,
128 QEMU_IFLA_VF_PORTS,
129 QEMU_IFLA_PORT_SELF,
130 QEMU_IFLA_AF_SPEC,
131 QEMU_IFLA_GROUP,
132 QEMU_IFLA_NET_NS_FD,
133 QEMU_IFLA_EXT_MASK,
134 QEMU_IFLA_PROMISCUITY,
135 QEMU_IFLA_NUM_TX_QUEUES,
136 QEMU_IFLA_NUM_RX_QUEUES,
137 QEMU_IFLA_CARRIER,
138 QEMU_IFLA_PHYS_PORT_ID,
139 QEMU_IFLA_CARRIER_CHANGES,
140 QEMU_IFLA_PHYS_SWITCH_ID,
141 QEMU_IFLA_LINK_NETNSID,
142 QEMU_IFLA_PHYS_PORT_NAME,
143 QEMU_IFLA_PROTO_DOWN,
144 QEMU_IFLA_GSO_MAX_SEGS,
145 QEMU_IFLA_GSO_MAX_SIZE,
146 QEMU_IFLA_PAD,
147 QEMU_IFLA_XDP,
148 QEMU_IFLA_EVENT,
149 QEMU_IFLA_NEW_NETNSID,
150 QEMU_IFLA_IF_NETNSID,
151 QEMU_IFLA_CARRIER_UP_COUNT,
152 QEMU_IFLA_CARRIER_DOWN_COUNT,
153 QEMU_IFLA_NEW_IFINDEX,
154 QEMU_IFLA_MIN_MTU,
155 QEMU_IFLA_MAX_MTU,
156 QEMU_IFLA_PROP_LIST,
157 QEMU_IFLA_ALT_IFNAME,
158 QEMU_IFLA_PERM_ADDRESS,
159 QEMU_IFLA_PROTO_DOWN_REASON,
160 QEMU_IFLA_PARENT_DEV_NAME,
161 QEMU_IFLA_PARENT_DEV_BUS_NAME,
162 QEMU_IFLA_GRO_MAX_SIZE,
163 QEMU_IFLA_TSO_MAX_SIZE,
164 QEMU_IFLA_TSO_MAX_SEGS,
165 QEMU_IFLA_ALLMULTI,
166 QEMU_IFLA_DEVLINK_PORT,
167 QEMU_IFLA_GSO_IPV4_MAX_SIZE,
168 QEMU_IFLA_GRO_IPV4_MAX_SIZE,
169 QEMU_IFLA_DPLL_PIN,
170 QEMU___IFLA_MAX
171 };
172
173 enum {
174 QEMU_IFLA_BRPORT_UNSPEC,
175 QEMU_IFLA_BRPORT_STATE,
176 QEMU_IFLA_BRPORT_PRIORITY,
177 QEMU_IFLA_BRPORT_COST,
178 QEMU_IFLA_BRPORT_MODE,
179 QEMU_IFLA_BRPORT_GUARD,
180 QEMU_IFLA_BRPORT_PROTECT,
181 QEMU_IFLA_BRPORT_FAST_LEAVE,
182 QEMU_IFLA_BRPORT_LEARNING,
183 QEMU_IFLA_BRPORT_UNICAST_FLOOD,
184 QEMU_IFLA_BRPORT_PROXYARP,
185 QEMU_IFLA_BRPORT_LEARNING_SYNC,
186 QEMU_IFLA_BRPORT_PROXYARP_WIFI,
187 QEMU_IFLA_BRPORT_ROOT_ID,
188 QEMU_IFLA_BRPORT_BRIDGE_ID,
189 QEMU_IFLA_BRPORT_DESIGNATED_PORT,
190 QEMU_IFLA_BRPORT_DESIGNATED_COST,
191 QEMU_IFLA_BRPORT_ID,
192 QEMU_IFLA_BRPORT_NO,
193 QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
194 QEMU_IFLA_BRPORT_CONFIG_PENDING,
195 QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER,
196 QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER,
197 QEMU_IFLA_BRPORT_HOLD_TIMER,
198 QEMU_IFLA_BRPORT_FLUSH,
199 QEMU_IFLA_BRPORT_MULTICAST_ROUTER,
200 QEMU_IFLA_BRPORT_PAD,
201 QEMU_IFLA_BRPORT_MCAST_FLOOD,
202 QEMU_IFLA_BRPORT_MCAST_TO_UCAST,
203 QEMU_IFLA_BRPORT_VLAN_TUNNEL,
204 QEMU_IFLA_BRPORT_BCAST_FLOOD,
205 QEMU_IFLA_BRPORT_GROUP_FWD_MASK,
206 QEMU_IFLA_BRPORT_NEIGH_SUPPRESS,
207 QEMU_IFLA_BRPORT_ISOLATED,
208 QEMU_IFLA_BRPORT_BACKUP_PORT,
209 QEMU_IFLA_BRPORT_MRP_RING_OPEN,
210 QEMU_IFLA_BRPORT_MRP_IN_OPEN,
211 QEMU_IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT,
212 QEMU_IFLA_BRPORT_MCAST_EHT_HOSTS_CNT,
213 QEMU___IFLA_BRPORT_MAX
214 };
215
216 enum {
217 QEMU_IFLA_TUN_UNSPEC,
218 QEMU_IFLA_TUN_OWNER,
219 QEMU_IFLA_TUN_GROUP,
220 QEMU_IFLA_TUN_TYPE,
221 QEMU_IFLA_TUN_PI,
222 QEMU_IFLA_TUN_VNET_HDR,
223 QEMU_IFLA_TUN_PERSIST,
224 QEMU_IFLA_TUN_MULTI_QUEUE,
225 QEMU_IFLA_TUN_NUM_QUEUES,
226 QEMU_IFLA_TUN_NUM_DISABLED_QUEUES,
227 QEMU___IFLA_TUN_MAX,
228 };
229
230 enum {
231 QEMU_IFLA_INFO_UNSPEC,
232 QEMU_IFLA_INFO_KIND,
233 QEMU_IFLA_INFO_DATA,
234 QEMU_IFLA_INFO_XSTATS,
235 QEMU_IFLA_INFO_SLAVE_KIND,
236 QEMU_IFLA_INFO_SLAVE_DATA,
237 QEMU___IFLA_INFO_MAX,
238 };
239
240 enum {
241 QEMU_IFLA_INET_UNSPEC,
242 QEMU_IFLA_INET_CONF,
243 QEMU___IFLA_INET_MAX,
244 };
245
246 enum {
247 QEMU_IFLA_INET6_UNSPEC,
248 QEMU_IFLA_INET6_FLAGS,
249 QEMU_IFLA_INET6_CONF,
250 QEMU_IFLA_INET6_STATS,
251 QEMU_IFLA_INET6_MCAST,
252 QEMU_IFLA_INET6_CACHEINFO,
253 QEMU_IFLA_INET6_ICMP6STATS,
254 QEMU_IFLA_INET6_TOKEN,
255 QEMU_IFLA_INET6_ADDR_GEN_MODE,
256 QEMU___IFLA_INET6_MAX
257 };
258
259 enum {
260 QEMU_IFLA_XDP_UNSPEC,
261 QEMU_IFLA_XDP_FD,
262 QEMU_IFLA_XDP_ATTACHED,
263 QEMU_IFLA_XDP_FLAGS,
264 QEMU_IFLA_XDP_PROG_ID,
265 QEMU___IFLA_XDP_MAX,
266 };
267
268 enum {
269 QEMU_RTA_UNSPEC,
270 QEMU_RTA_DST,
271 QEMU_RTA_SRC,
272 QEMU_RTA_IIF,
273 QEMU_RTA_OIF,
274 QEMU_RTA_GATEWAY,
275 QEMU_RTA_PRIORITY,
276 QEMU_RTA_PREFSRC,
277 QEMU_RTA_METRICS,
278 QEMU_RTA_MULTIPATH,
279 QEMU_RTA_PROTOINFO, /* no longer used */
280 QEMU_RTA_FLOW,
281 QEMU_RTA_CACHEINFO,
282 QEMU_RTA_SESSION, /* no longer used */
283 QEMU_RTA_MP_ALGO, /* no longer used */
284 QEMU_RTA_TABLE,
285 QEMU_RTA_MARK,
286 QEMU_RTA_MFC_STATS,
287 QEMU_RTA_VIA,
288 QEMU_RTA_NEWDST,
289 QEMU_RTA_PREF,
290 QEMU_RTA_ENCAP_TYPE,
291 QEMU_RTA_ENCAP,
292 QEMU_RTA_EXPIRES,
293 QEMU_RTA_PAD,
294 QEMU_RTA_UID,
295 QEMU_RTA_TTL_PROPAGATE,
296 QEMU_RTA_IP_PROTO,
297 QEMU_RTA_SPORT,
298 QEMU_RTA_DPORT,
299 QEMU___RTA_MAX
300 };
301
302 enum {
303 QEMU_IFLA_VF_STATS_RX_PACKETS,
304 QEMU_IFLA_VF_STATS_TX_PACKETS,
305 QEMU_IFLA_VF_STATS_RX_BYTES,
306 QEMU_IFLA_VF_STATS_TX_BYTES,
307 QEMU_IFLA_VF_STATS_BROADCAST,
308 QEMU_IFLA_VF_STATS_MULTICAST,
309 QEMU_IFLA_VF_STATS_PAD,
310 QEMU_IFLA_VF_STATS_RX_DROPPED,
311 QEMU_IFLA_VF_STATS_TX_DROPPED,
312 QEMU__IFLA_VF_STATS_MAX,
313 };
314
315 enum {
316 QEMU_IFLA_VF_UNSPEC,
317 QEMU_IFLA_VF_MAC,
318 QEMU_IFLA_VF_VLAN,
319 QEMU_IFLA_VF_TX_RATE,
320 QEMU_IFLA_VF_SPOOFCHK,
321 QEMU_IFLA_VF_LINK_STATE,
322 QEMU_IFLA_VF_RATE,
323 QEMU_IFLA_VF_RSS_QUERY_EN,
324 QEMU_IFLA_VF_STATS,
325 QEMU_IFLA_VF_TRUST,
326 QEMU_IFLA_VF_IB_NODE_GUID,
327 QEMU_IFLA_VF_IB_PORT_GUID,
328 QEMU_IFLA_VF_VLAN_LIST,
329 QEMU_IFLA_VF_BROADCAST,
330 QEMU__IFLA_VF_MAX,
331 };
332
333 TargetFdTrans **target_fd_trans;
334 QemuMutex target_fd_trans_lock;
335 unsigned int target_fd_max;
336
337 static void tswap_nlmsghdr(struct nlmsghdr *nlh)
338 {
339 nlh->nlmsg_len = tswap32(nlh->nlmsg_len);
340 nlh->nlmsg_type = tswap16(nlh->nlmsg_type);
341 nlh->nlmsg_flags = tswap16(nlh->nlmsg_flags);
342 nlh->nlmsg_seq = tswap32(nlh->nlmsg_seq);
343 nlh->nlmsg_pid = tswap32(nlh->nlmsg_pid);
344 }
345
346 static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
347 size_t len,
348 abi_long (*host_to_target_nlmsg)
349 (struct nlmsghdr *))
350 {
351 uint32_t nlmsg_len;
352 uint32_t aligned_nlmsg_len;
353 abi_long ret;
354
355 while (len > sizeof(struct nlmsghdr)) {
356
357 nlmsg_len = nlh->nlmsg_len;
358 if (nlmsg_len < sizeof(struct nlmsghdr) ||
359 nlmsg_len > len) {
360 break;
361 }
362
363 switch (nlh->nlmsg_type) {
364 case NLMSG_DONE:
365 tswap_nlmsghdr(nlh);
366 return 0;
367 case NLMSG_NOOP:
368 break;
369 case NLMSG_ERROR:
370 {
371 struct nlmsgerr *e = NLMSG_DATA(nlh);
372 e->error = tswap32(e->error);
373 tswap_nlmsghdr(&e->msg);
374 tswap_nlmsghdr(nlh);
375 return 0;
376 }
377 default:
378 ret = host_to_target_nlmsg(nlh);
379 if (ret < 0) {
380 tswap_nlmsghdr(nlh);
381 return ret;
382 }
383 break;
384 }
385 tswap_nlmsghdr(nlh);
386
387 aligned_nlmsg_len = NLMSG_ALIGN(nlmsg_len);
388 if (aligned_nlmsg_len >= len) {
389 break;
390 }
391 len -= aligned_nlmsg_len;
392 nlh = (struct nlmsghdr *)(((char*)nlh) + aligned_nlmsg_len);
393 }
394 return 0;
395 }
396
397 static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
398 size_t len,
399 abi_long (*target_to_host_nlmsg)
400 (struct nlmsghdr *))
401 {
402 uint32_t aligned_nlmsg_len;
403 int ret;
404
405 while (len > sizeof(struct nlmsghdr)) {
406 if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) ||
407 tswap32(nlh->nlmsg_len) > len) {
408 break;
409 }
410 tswap_nlmsghdr(nlh);
411 switch (nlh->nlmsg_type) {
412 case NLMSG_DONE:
413 return 0;
414 case NLMSG_NOOP:
415 break;
416 case NLMSG_ERROR:
417 {
418 struct nlmsgerr *e = NLMSG_DATA(nlh);
419 e->error = tswap32(e->error);
420 tswap_nlmsghdr(&e->msg);
421 return 0;
422 }
423 default:
424 ret = target_to_host_nlmsg(nlh);
425 if (ret < 0) {
426 return ret;
427 }
428 }
429
430 aligned_nlmsg_len = NLMSG_ALIGN(nlh->nlmsg_len);
431 if (aligned_nlmsg_len >= len) {
432 break;
433 }
434 len -= aligned_nlmsg_len;
435 nlh = (struct nlmsghdr *)(((char *)nlh) + aligned_nlmsg_len);
436 }
437 return 0;
438 }
439
440 #ifdef CONFIG_RTNETLINK
441 static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
442 size_t len, void *context,
443 abi_long (*host_to_target_nlattr)
444 (struct nlattr *,
445 void *context))
446 {
447 unsigned short nla_len;
448 unsigned short aligned_nla_len;
449 abi_long ret;
450
451 while (len > sizeof(struct nlattr)) {
452 nla_len = nlattr->nla_len;
453 if (nla_len < sizeof(struct nlattr) ||
454 nla_len > len) {
455 break;
456 }
457 ret = host_to_target_nlattr(nlattr, context);
458 nlattr->nla_len = tswap16(nlattr->nla_len);
459 nlattr->nla_type = tswap16(nlattr->nla_type);
460 if (ret < 0) {
461 return ret;
462 }
463
464 aligned_nla_len = NLA_ALIGN(nla_len);
465 if (aligned_nla_len >= len) {
466 break;
467 }
468 len -= aligned_nla_len;
469 nlattr = (struct nlattr *)(((char *)nlattr) + aligned_nla_len);
470 }
471 return 0;
472 }
473
474 static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
475 size_t len,
476 abi_long (*host_to_target_rtattr)
477 (struct rtattr *))
478 {
479 unsigned short rta_len;
480 unsigned short aligned_rta_len;
481 abi_long ret;
482
483 while (len >= sizeof(struct rtattr)) {
484 rta_len = rtattr->rta_len;
485 if (rta_len < sizeof(struct rtattr) ||
486 rta_len > len) {
487 break;
488 }
489 ret = host_to_target_rtattr(rtattr);
490 rtattr->rta_len = tswap16(rtattr->rta_len);
491 rtattr->rta_type = tswap16(rtattr->rta_type);
492 if (ret < 0) {
493 return ret;
494 }
495
496 aligned_rta_len = RTA_ALIGN(rta_len);
497 if (aligned_rta_len >= len) {
498 break;
499 }
500 len -= aligned_rta_len;
501 rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
502 }
503 return 0;
504 }
505
506 #define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN)
507
508 static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr,
509 void *context)
510 {
511 uint16_t *u16;
512 uint32_t *u32;
513 uint64_t *u64;
514
515 switch (nlattr->nla_type) {
516 /* no data */
517 case QEMU_IFLA_BR_FDB_FLUSH:
518 break;
519 /* binary */
520 case QEMU_IFLA_BR_GROUP_ADDR:
521 break;
522 /* uint8_t */
523 case QEMU_IFLA_BR_VLAN_FILTERING:
524 case QEMU_IFLA_BR_TOPOLOGY_CHANGE:
525 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED:
526 case QEMU_IFLA_BR_MCAST_ROUTER:
527 case QEMU_IFLA_BR_MCAST_SNOOPING:
528 case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR:
529 case QEMU_IFLA_BR_MCAST_QUERIER:
530 case QEMU_IFLA_BR_NF_CALL_IPTABLES:
531 case QEMU_IFLA_BR_NF_CALL_IP6TABLES:
532 case QEMU_IFLA_BR_NF_CALL_ARPTABLES:
533 case QEMU_IFLA_BR_VLAN_STATS_ENABLED:
534 case QEMU_IFLA_BR_MCAST_STATS_ENABLED:
535 case QEMU_IFLA_BR_MCAST_IGMP_VERSION:
536 case QEMU_IFLA_BR_MCAST_MLD_VERSION:
537 case QEMU_IFLA_BR_VLAN_STATS_PER_PORT:
538 break;
539 /* uint16_t */
540 case QEMU_IFLA_BR_PRIORITY:
541 case QEMU_IFLA_BR_VLAN_PROTOCOL:
542 case QEMU_IFLA_BR_GROUP_FWD_MASK:
543 case QEMU_IFLA_BR_ROOT_PORT:
544 case QEMU_IFLA_BR_VLAN_DEFAULT_PVID:
545 u16 = NLA_DATA(nlattr);
546 *u16 = tswap16(*u16);
547 break;
548 /* uint32_t */
549 case QEMU_IFLA_BR_FORWARD_DELAY:
550 case QEMU_IFLA_BR_HELLO_TIME:
551 case QEMU_IFLA_BR_MAX_AGE:
552 case QEMU_IFLA_BR_AGEING_TIME:
553 case QEMU_IFLA_BR_STP_STATE:
554 case QEMU_IFLA_BR_ROOT_PATH_COST:
555 case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY:
556 case QEMU_IFLA_BR_MCAST_HASH_MAX:
557 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT:
558 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT:
559 u32 = NLA_DATA(nlattr);
560 *u32 = tswap32(*u32);
561 break;
562 /* uint64_t */
563 case QEMU_IFLA_BR_HELLO_TIMER:
564 case QEMU_IFLA_BR_TCN_TIMER:
565 case QEMU_IFLA_BR_GC_TIMER:
566 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER:
567 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL:
568 case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL:
569 case QEMU_IFLA_BR_MCAST_QUERIER_INTVL:
570 case QEMU_IFLA_BR_MCAST_QUERY_INTVL:
571 case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL:
572 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL:
573 u64 = NLA_DATA(nlattr);
574 *u64 = tswap64(*u64);
575 break;
576 /* ifla_bridge_id: uin8_t[] */
577 case QEMU_IFLA_BR_ROOT_ID:
578 case QEMU_IFLA_BR_BRIDGE_ID:
579 break;
580 /* br_boolopt_multi { uint32_t, uint32_t } */
581 case QEMU_IFLA_BR_MULTI_BOOLOPT:
582 u32 = NLA_DATA(nlattr);
583 u32[0] = tswap32(u32[0]); /* optval */
584 u32[1] = tswap32(u32[1]); /* optmask */
585 break;
586 default:
587 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_BR type %d\n",
588 nlattr->nla_type);
589 break;
590 }
591 return 0;
592 }
593
594 static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nlattr,
595 void *context)
596 {
597 uint16_t *u16;
598 uint32_t *u32;
599 uint64_t *u64;
600
601 switch (nlattr->nla_type) {
602 /* uint8_t */
603 case QEMU_IFLA_BRPORT_STATE:
604 case QEMU_IFLA_BRPORT_MODE:
605 case QEMU_IFLA_BRPORT_GUARD:
606 case QEMU_IFLA_BRPORT_PROTECT:
607 case QEMU_IFLA_BRPORT_FAST_LEAVE:
608 case QEMU_IFLA_BRPORT_LEARNING:
609 case QEMU_IFLA_BRPORT_UNICAST_FLOOD:
610 case QEMU_IFLA_BRPORT_PROXYARP:
611 case QEMU_IFLA_BRPORT_LEARNING_SYNC:
612 case QEMU_IFLA_BRPORT_PROXYARP_WIFI:
613 case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK:
614 case QEMU_IFLA_BRPORT_CONFIG_PENDING:
615 case QEMU_IFLA_BRPORT_MULTICAST_ROUTER:
616 case QEMU_IFLA_BRPORT_MCAST_FLOOD:
617 case QEMU_IFLA_BRPORT_MCAST_TO_UCAST:
618 case QEMU_IFLA_BRPORT_VLAN_TUNNEL:
619 case QEMU_IFLA_BRPORT_BCAST_FLOOD:
620 case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS:
621 case QEMU_IFLA_BRPORT_ISOLATED:
622 case QEMU_IFLA_BRPORT_MRP_RING_OPEN:
623 case QEMU_IFLA_BRPORT_MRP_IN_OPEN:
624 break;
625 /* uint16_t */
626 case QEMU_IFLA_BRPORT_PRIORITY:
627 case QEMU_IFLA_BRPORT_DESIGNATED_PORT:
628 case QEMU_IFLA_BRPORT_DESIGNATED_COST:
629 case QEMU_IFLA_BRPORT_ID:
630 case QEMU_IFLA_BRPORT_NO:
631 case QEMU_IFLA_BRPORT_GROUP_FWD_MASK:
632 u16 = NLA_DATA(nlattr);
633 *u16 = tswap16(*u16);
634 break;
635 /* uin32_t */
636 case QEMU_IFLA_BRPORT_COST:
637 case QEMU_IFLA_BRPORT_BACKUP_PORT:
638 case QEMU_IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT:
639 case QEMU_IFLA_BRPORT_MCAST_EHT_HOSTS_CNT:
640 u32 = NLA_DATA(nlattr);
641 *u32 = tswap32(*u32);
642 break;
643 /* uint64_t */
644 case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER:
645 case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER:
646 case QEMU_IFLA_BRPORT_HOLD_TIMER:
647 u64 = NLA_DATA(nlattr);
648 *u64 = tswap64(*u64);
649 break;
650 /* ifla_bridge_id: uint8_t[] */
651 case QEMU_IFLA_BRPORT_ROOT_ID:
652 case QEMU_IFLA_BRPORT_BRIDGE_ID:
653 break;
654 default:
655 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_BRPORT type %d\n",
656 nlattr->nla_type);
657 break;
658 }
659 return 0;
660 }
661
662 static abi_long host_to_target_data_tun_nlattr(struct nlattr *nlattr,
663 void *context)
664 {
665 uint32_t *u32;
666
667 switch (nlattr->nla_type) {
668 /* uint8_t */
669 case QEMU_IFLA_TUN_TYPE:
670 case QEMU_IFLA_TUN_PI:
671 case QEMU_IFLA_TUN_VNET_HDR:
672 case QEMU_IFLA_TUN_PERSIST:
673 case QEMU_IFLA_TUN_MULTI_QUEUE:
674 break;
675 /* uint32_t */
676 case QEMU_IFLA_TUN_NUM_QUEUES:
677 case QEMU_IFLA_TUN_NUM_DISABLED_QUEUES:
678 case QEMU_IFLA_TUN_OWNER:
679 case QEMU_IFLA_TUN_GROUP:
680 u32 = NLA_DATA(nlattr);
681 *u32 = tswap32(*u32);
682 break;
683 default:
684 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_TUN type %d\n",
685 nlattr->nla_type);
686 break;
687 }
688 return 0;
689 }
690
691 struct linkinfo_context {
692 int len;
693 char *name;
694 int slave_len;
695 char *slave_name;
696 };
697
698 static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr,
699 void *context)
700 {
701 struct linkinfo_context *li_context = context;
702
703 switch (nlattr->nla_type) {
704 /* string */
705 case QEMU_IFLA_INFO_KIND:
706 li_context->name = NLA_DATA(nlattr);
707 li_context->len = nlattr->nla_len - NLA_HDRLEN;
708 break;
709 case QEMU_IFLA_INFO_SLAVE_KIND:
710 li_context->slave_name = NLA_DATA(nlattr);
711 li_context->slave_len = nlattr->nla_len - NLA_HDRLEN;
712 break;
713 /* stats */
714 case QEMU_IFLA_INFO_XSTATS:
715 /* FIXME: only used by CAN */
716 break;
717 /* nested */
718 case QEMU_IFLA_INFO_DATA:
719 if (strncmp(li_context->name, "bridge",
720 li_context->len) == 0) {
721 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
722 nlattr->nla_len,
723 NULL,
724 host_to_target_data_bridge_nlattr);
725 } else if (strncmp(li_context->name, "tun",
726 li_context->len) == 0) {
727 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
728 nlattr->nla_len,
729 NULL,
730 host_to_target_data_tun_nlattr);
731 } else {
732 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_INFO_KIND %s\n",
733 li_context->name);
734 }
735 break;
736 case QEMU_IFLA_INFO_SLAVE_DATA:
737 if (strncmp(li_context->slave_name, "bridge",
738 li_context->slave_len) == 0) {
739 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
740 nlattr->nla_len,
741 NULL,
742 host_to_target_slave_data_bridge_nlattr);
743 } else {
744 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n",
745 li_context->slave_name);
746 }
747 break;
748 default:
749 qemu_log_mask(LOG_UNIMP, "Unknown host QEMU_IFLA_INFO type: %d\n",
750 nlattr->nla_type);
751 break;
752 }
753
754 return 0;
755 }
756
757 static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr,
758 void *context)
759 {
760 uint32_t *u32;
761 int i;
762
763 switch (nlattr->nla_type) {
764 case QEMU_IFLA_INET_CONF:
765 u32 = NLA_DATA(nlattr);
766 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
767 i++) {
768 u32[i] = tswap32(u32[i]);
769 }
770 break;
771 default:
772 qemu_log_mask(LOG_UNIMP, "Unknown host AF_INET type: %d\n",
773 nlattr->nla_type);
774 }
775 return 0;
776 }
777
778 static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr,
779 void *context)
780 {
781 uint32_t *u32;
782 uint64_t *u64;
783 struct ifla_cacheinfo *ci;
784 int i;
785
786 switch (nlattr->nla_type) {
787 /* binaries */
788 case QEMU_IFLA_INET6_TOKEN:
789 break;
790 /* uint8_t */
791 case QEMU_IFLA_INET6_ADDR_GEN_MODE:
792 break;
793 /* uint32_t */
794 case QEMU_IFLA_INET6_FLAGS:
795 u32 = NLA_DATA(nlattr);
796 *u32 = tswap32(*u32);
797 break;
798 /* uint32_t[] */
799 case QEMU_IFLA_INET6_CONF:
800 u32 = NLA_DATA(nlattr);
801 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
802 i++) {
803 u32[i] = tswap32(u32[i]);
804 }
805 break;
806 /* ifla_cacheinfo */
807 case QEMU_IFLA_INET6_CACHEINFO:
808 ci = NLA_DATA(nlattr);
809 ci->max_reasm_len = tswap32(ci->max_reasm_len);
810 ci->tstamp = tswap32(ci->tstamp);
811 ci->reachable_time = tswap32(ci->reachable_time);
812 ci->retrans_time = tswap32(ci->retrans_time);
813 break;
814 /* uint64_t[] */
815 case QEMU_IFLA_INET6_STATS:
816 case QEMU_IFLA_INET6_ICMP6STATS:
817 u64 = NLA_DATA(nlattr);
818 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64);
819 i++) {
820 u64[i] = tswap64(u64[i]);
821 }
822 break;
823 default:
824 qemu_log_mask(LOG_UNIMP, "Unknown host AF_INET6 type: %d\n",
825 nlattr->nla_type);
826 }
827 return 0;
828 }
829
830 static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr,
831 void *context)
832 {
833 switch (nlattr->nla_type) {
834 case AF_INET:
835 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
836 NULL,
837 host_to_target_data_inet_nlattr);
838 case AF_INET6:
839 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
840 NULL,
841 host_to_target_data_inet6_nlattr);
842 default:
843 qemu_log_mask(LOG_UNIMP, "Unknown host AF_SPEC type: %d\n",
844 nlattr->nla_type);
845 break;
846 }
847 return 0;
848 }
849
850 static abi_long host_to_target_data_xdp_nlattr(struct nlattr *nlattr,
851 void *context)
852 {
853 uint32_t *u32;
854
855 switch (nlattr->nla_type) {
856 /* uint8_t */
857 case QEMU_IFLA_XDP_ATTACHED:
858 break;
859 /* uint32_t */
860 case QEMU_IFLA_XDP_PROG_ID:
861 u32 = NLA_DATA(nlattr);
862 *u32 = tswap32(*u32);
863 break;
864 default:
865 qemu_log_mask(
866 LOG_UNIMP, "Unknown host XDP type: %d\n", nlattr->nla_type);
867 break;
868 }
869 return 0;
870 }
871
872 static abi_long host_to_target_data_vlan_list_nlattr(struct nlattr *nlattr,
873 void *context)
874 {
875 struct ifla_vf_vlan_info *vlan_info;
876
877 switch (nlattr->nla_type) {
878 /* struct ifla_vf_vlan_info */
879 case IFLA_VF_VLAN_INFO:
880 vlan_info = NLA_DATA(nlattr);
881 vlan_info->vf = tswap32(vlan_info->vf);
882 vlan_info->vlan = tswap32(vlan_info->vlan);
883 vlan_info->qos = tswap32(vlan_info->qos);
884 break;
885 default:
886 qemu_log_mask(LOG_UNIMP, "Unknown host VLAN LIST type: %d\n",
887 nlattr->nla_type);
888 break;
889 }
890 return 0;
891 }
892
893 static abi_long host_to_target_data_vf_stats_nlattr(struct nlattr *nlattr,
894 void *context)
895 {
896 uint64_t *u64;
897
898 switch (nlattr->nla_type) {
899 /* uint64_t */
900 case QEMU_IFLA_VF_STATS_RX_PACKETS:
901 case QEMU_IFLA_VF_STATS_TX_PACKETS:
902 case QEMU_IFLA_VF_STATS_RX_BYTES:
903 case QEMU_IFLA_VF_STATS_TX_BYTES:
904 case QEMU_IFLA_VF_STATS_BROADCAST:
905 case QEMU_IFLA_VF_STATS_MULTICAST:
906 case QEMU_IFLA_VF_STATS_PAD:
907 case QEMU_IFLA_VF_STATS_RX_DROPPED:
908 case QEMU_IFLA_VF_STATS_TX_DROPPED:
909 u64 = NLA_DATA(nlattr);
910 *u64 = tswap64(*u64);
911 break;
912 default:
913 qemu_log_mask(LOG_UNIMP, "Unknown host VF STATS type: %d\n",
914 nlattr->nla_type);
915 break;
916 }
917 return 0;
918 }
919
920 static abi_long host_to_target_data_vfinfo_nlattr(struct nlattr *nlattr,
921 void *context)
922 {
923 struct ifla_vf_mac *mac;
924 struct ifla_vf_vlan *vlan;
925 struct ifla_vf_vlan_info *vlan_info;
926 struct ifla_vf_spoofchk *spoofchk;
927 struct ifla_vf_rate *rate;
928 struct ifla_vf_link_state *link_state;
929 struct ifla_vf_rss_query_en *rss_query_en;
930 struct ifla_vf_trust *trust;
931 struct ifla_vf_guid *guid;
932
933 switch (nlattr->nla_type) {
934 /* struct ifla_vf_mac */
935 case QEMU_IFLA_VF_MAC:
936 mac = NLA_DATA(nlattr);
937 mac->vf = tswap32(mac->vf);
938 break;
939 /* struct ifla_vf_broadcast */
940 case QEMU_IFLA_VF_BROADCAST:
941 break;
942 /* struct struct ifla_vf_vlan */
943 case QEMU_IFLA_VF_VLAN:
944 vlan = NLA_DATA(nlattr);
945 vlan->vf = tswap32(vlan->vf);
946 vlan->vlan = tswap32(vlan->vlan);
947 vlan->qos = tswap32(vlan->qos);
948 break;
949 /* struct ifla_vf_vlan_info */
950 case QEMU_IFLA_VF_TX_RATE:
951 vlan_info = NLA_DATA(nlattr);
952 vlan_info->vf = tswap32(vlan_info->vf);
953 vlan_info->vlan = tswap32(vlan_info->vlan);
954 vlan_info->qos = tswap32(vlan_info->qos);
955 break;
956 /* struct ifla_vf_spoofchk */
957 case QEMU_IFLA_VF_SPOOFCHK:
958 spoofchk = NLA_DATA(nlattr);
959 spoofchk->vf = tswap32(spoofchk->vf);
960 spoofchk->setting = tswap32(spoofchk->setting);
961 break;
962 /* struct ifla_vf_rate */
963 case QEMU_IFLA_VF_RATE:
964 rate = NLA_DATA(nlattr);
965 rate->vf = tswap32(rate->vf);
966 rate->min_tx_rate = tswap32(rate->min_tx_rate);
967 rate->max_tx_rate = tswap32(rate->max_tx_rate);
968 break;
969 /* struct ifla_vf_link_state */
970 case QEMU_IFLA_VF_LINK_STATE:
971 link_state = NLA_DATA(nlattr);
972 link_state->vf = tswap32(link_state->vf);
973 link_state->link_state = tswap32(link_state->link_state);
974 break;
975 /* struct ifla_vf_rss_query_en */
976 case QEMU_IFLA_VF_RSS_QUERY_EN:
977 rss_query_en = NLA_DATA(nlattr);
978 rss_query_en->vf = tswap32(rss_query_en->vf);
979 rss_query_en->setting = tswap32(rss_query_en->setting);
980 break;
981 /* struct ifla_vf_trust */
982 case QEMU_IFLA_VF_TRUST:
983 trust = NLA_DATA(nlattr);
984 trust->vf = tswap32(trust->vf);
985 trust->setting = tswap32(trust->setting);
986 break;
987 /* struct ifla_vf_guid */
988 case QEMU_IFLA_VF_IB_NODE_GUID:
989 case QEMU_IFLA_VF_IB_PORT_GUID:
990 guid = NLA_DATA(nlattr);
991 guid->vf = tswap32(guid->vf);
992 guid->guid = tswap32(guid->guid);
993 break;
994 /* nested */
995 case QEMU_IFLA_VF_VLAN_LIST:
996 return host_to_target_for_each_nlattr(RTA_DATA(nlattr), nlattr->nla_len,
997 NULL,
998 host_to_target_data_vlan_list_nlattr);
999 case QEMU_IFLA_VF_STATS:
1000 return host_to_target_for_each_nlattr(RTA_DATA(nlattr), nlattr->nla_len,
1001 NULL,
1002 host_to_target_data_vf_stats_nlattr);
1003 default:
1004 qemu_log_mask(LOG_UNIMP, "Unknown host VFINFO type: %d\n",
1005 nlattr->nla_type);
1006 break;
1007 }
1008 return 0;
1009 }
1010
1011 static abi_long host_to_target_data_prop_nlattr(struct nlattr *nlattr,
1012 void *context)
1013 {
1014 switch (nlattr->nla_type) {
1015 /* string */
1016 case QEMU_IFLA_ALT_IFNAME:
1017 break;
1018 default:
1019 qemu_log_mask(LOG_UNIMP, "Unknown host PROP type: %d\n",
1020 nlattr->nla_type);
1021 break;
1022 }
1023 return 0;
1024 }
1025
1026
1027 static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr)
1028 {
1029 uint32_t *u32;
1030 struct rtnl_link_stats *st;
1031 struct rtnl_link_stats64 *st64;
1032 struct rtnl_link_ifmap *map;
1033 struct linkinfo_context li_context;
1034
1035 switch (rtattr->rta_type & NLA_TYPE_MASK) {
1036 /* binary stream */
1037 case QEMU_IFLA_ADDRESS:
1038 case QEMU_IFLA_BROADCAST:
1039 case QEMU_IFLA_PERM_ADDRESS:
1040 case QEMU_IFLA_PHYS_PORT_ID:
1041 /* string */
1042 case QEMU_IFLA_IFNAME:
1043 case QEMU_IFLA_QDISC:
1044 case QEMU_IFLA_PARENT_DEV_NAME:
1045 case QEMU_IFLA_PARENT_DEV_BUS_NAME:
1046 break;
1047 /* uin8_t */
1048 case QEMU_IFLA_OPERSTATE:
1049 case QEMU_IFLA_LINKMODE:
1050 case QEMU_IFLA_CARRIER:
1051 case QEMU_IFLA_PROTO_DOWN:
1052 break;
1053 /* uint32_t */
1054 case QEMU_IFLA_MTU:
1055 case QEMU_IFLA_LINK:
1056 case QEMU_IFLA_WEIGHT:
1057 case QEMU_IFLA_TXQLEN:
1058 case QEMU_IFLA_CARRIER_CHANGES:
1059 case QEMU_IFLA_NUM_RX_QUEUES:
1060 case QEMU_IFLA_NUM_TX_QUEUES:
1061 case QEMU_IFLA_PROMISCUITY:
1062 case QEMU_IFLA_EXT_MASK:
1063 case QEMU_IFLA_LINK_NETNSID:
1064 case QEMU_IFLA_GROUP:
1065 case QEMU_IFLA_MASTER:
1066 case QEMU_IFLA_NUM_VF:
1067 case QEMU_IFLA_GSO_MAX_SEGS:
1068 case QEMU_IFLA_GSO_MAX_SIZE:
1069 case QEMU_IFLA_CARRIER_UP_COUNT:
1070 case QEMU_IFLA_CARRIER_DOWN_COUNT:
1071 case QEMU_IFLA_MIN_MTU:
1072 case QEMU_IFLA_MAX_MTU:
1073 case QEMU_IFLA_GRO_MAX_SIZE:
1074 case QEMU_IFLA_TSO_MAX_SIZE:
1075 case QEMU_IFLA_TSO_MAX_SEGS:
1076 case QEMU_IFLA_ALLMULTI:
1077 case QEMU_IFLA_GSO_IPV4_MAX_SIZE:
1078 case QEMU_IFLA_GRO_IPV4_MAX_SIZE:
1079 u32 = RTA_DATA(rtattr);
1080 *u32 = tswap32(*u32);
1081 break;
1082 /* struct rtnl_link_stats */
1083 case QEMU_IFLA_STATS:
1084 st = RTA_DATA(rtattr);
1085 st->rx_packets = tswap32(st->rx_packets);
1086 st->tx_packets = tswap32(st->tx_packets);
1087 st->rx_bytes = tswap32(st->rx_bytes);
1088 st->tx_bytes = tswap32(st->tx_bytes);
1089 st->rx_errors = tswap32(st->rx_errors);
1090 st->tx_errors = tswap32(st->tx_errors);
1091 st->rx_dropped = tswap32(st->rx_dropped);
1092 st->tx_dropped = tswap32(st->tx_dropped);
1093 st->multicast = tswap32(st->multicast);
1094 st->collisions = tswap32(st->collisions);
1095
1096 /* detailed rx_errors: */
1097 st->rx_length_errors = tswap32(st->rx_length_errors);
1098 st->rx_over_errors = tswap32(st->rx_over_errors);
1099 st->rx_crc_errors = tswap32(st->rx_crc_errors);
1100 st->rx_frame_errors = tswap32(st->rx_frame_errors);
1101 st->rx_fifo_errors = tswap32(st->rx_fifo_errors);
1102 st->rx_missed_errors = tswap32(st->rx_missed_errors);
1103
1104 /* detailed tx_errors */
1105 st->tx_aborted_errors = tswap32(st->tx_aborted_errors);
1106 st->tx_carrier_errors = tswap32(st->tx_carrier_errors);
1107 st->tx_fifo_errors = tswap32(st->tx_fifo_errors);
1108 st->tx_heartbeat_errors = tswap32(st->tx_heartbeat_errors);
1109 st->tx_window_errors = tswap32(st->tx_window_errors);
1110
1111 /* for cslip etc */
1112 st->rx_compressed = tswap32(st->rx_compressed);
1113 st->tx_compressed = tswap32(st->tx_compressed);
1114 break;
1115 /* struct rtnl_link_stats64 */
1116 case QEMU_IFLA_STATS64:
1117 st64 = RTA_DATA(rtattr);
1118 st64->rx_packets = tswap64(st64->rx_packets);
1119 st64->tx_packets = tswap64(st64->tx_packets);
1120 st64->rx_bytes = tswap64(st64->rx_bytes);
1121 st64->tx_bytes = tswap64(st64->tx_bytes);
1122 st64->rx_errors = tswap64(st64->rx_errors);
1123 st64->tx_errors = tswap64(st64->tx_errors);
1124 st64->rx_dropped = tswap64(st64->rx_dropped);
1125 st64->tx_dropped = tswap64(st64->tx_dropped);
1126 st64->multicast = tswap64(st64->multicast);
1127 st64->collisions = tswap64(st64->collisions);
1128
1129 /* detailed rx_errors: */
1130 st64->rx_length_errors = tswap64(st64->rx_length_errors);
1131 st64->rx_over_errors = tswap64(st64->rx_over_errors);
1132 st64->rx_crc_errors = tswap64(st64->rx_crc_errors);
1133 st64->rx_frame_errors = tswap64(st64->rx_frame_errors);
1134 st64->rx_fifo_errors = tswap64(st64->rx_fifo_errors);
1135 st64->rx_missed_errors = tswap64(st64->rx_missed_errors);
1136
1137 /* detailed tx_errors */
1138 st64->tx_aborted_errors = tswap64(st64->tx_aborted_errors);
1139 st64->tx_carrier_errors = tswap64(st64->tx_carrier_errors);
1140 st64->tx_fifo_errors = tswap64(st64->tx_fifo_errors);
1141 st64->tx_heartbeat_errors = tswap64(st64->tx_heartbeat_errors);
1142 st64->tx_window_errors = tswap64(st64->tx_window_errors);
1143
1144 /* for cslip etc */
1145 st64->rx_compressed = tswap64(st64->rx_compressed);
1146 st64->tx_compressed = tswap64(st64->tx_compressed);
1147 break;
1148 /* struct rtnl_link_ifmap */
1149 case QEMU_IFLA_MAP:
1150 map = RTA_DATA(rtattr);
1151 map->mem_start = tswap64(map->mem_start);
1152 map->mem_end = tswap64(map->mem_end);
1153 map->base_addr = tswap64(map->base_addr);
1154 map->irq = tswap16(map->irq);
1155 break;
1156 /* nested */
1157 case QEMU_IFLA_LINKINFO:
1158 memset(&li_context, 0, sizeof(li_context));
1159 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
1160 &li_context,
1161 host_to_target_data_linkinfo_nlattr);
1162 case QEMU_IFLA_AF_SPEC:
1163 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
1164 NULL,
1165 host_to_target_data_spec_nlattr);
1166 case QEMU_IFLA_XDP:
1167 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
1168 NULL,
1169 host_to_target_data_xdp_nlattr);
1170 case QEMU_IFLA_VFINFO_LIST:
1171 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
1172 NULL,
1173 host_to_target_data_vfinfo_nlattr);
1174 case QEMU_IFLA_PROP_LIST:
1175 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
1176 NULL,
1177 host_to_target_data_prop_nlattr);
1178 default:
1179 qemu_log_mask(LOG_UNIMP, "Unknown host QEMU_IFLA type: %d\n",
1180 rtattr->rta_type);
1181 break;
1182 }
1183 return 0;
1184 }
1185
1186 static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr)
1187 {
1188 uint32_t *u32;
1189 struct ifa_cacheinfo *ci;
1190
1191 switch (rtattr->rta_type) {
1192 /* binary: depends on family type */
1193 case QEMU_IFA_ADDRESS:
1194 case QEMU_IFA_LOCAL:
1195 case QEMU_IFA_PROTO:
1196 break;
1197 /* string */
1198 case QEMU_IFA_LABEL:
1199 break;
1200 /* u32 */
1201 case QEMU_IFA_FLAGS:
1202 case QEMU_IFA_BROADCAST:
1203 u32 = RTA_DATA(rtattr);
1204 *u32 = tswap32(*u32);
1205 break;
1206 /* struct ifa_cacheinfo */
1207 case QEMU_IFA_CACHEINFO:
1208 ci = RTA_DATA(rtattr);
1209 ci->ifa_prefered = tswap32(ci->ifa_prefered);
1210 ci->ifa_valid = tswap32(ci->ifa_valid);
1211 ci->cstamp = tswap32(ci->cstamp);
1212 ci->tstamp = tswap32(ci->tstamp);
1213 break;
1214 default:
1215 qemu_log_mask(
1216 LOG_UNIMP, "Unknown host IFA type: %d\n", rtattr->rta_type);
1217 break;
1218 }
1219 return 0;
1220 }
1221
1222 static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr)
1223 {
1224 uint32_t *u32;
1225 struct rta_cacheinfo *ci;
1226
1227 switch (rtattr->rta_type) {
1228 /* binary: depends on family type */
1229 case QEMU_RTA_GATEWAY:
1230 case QEMU_RTA_DST:
1231 case QEMU_RTA_PREFSRC:
1232 break;
1233 /* u8 */
1234 case QEMU_RTA_PREF:
1235 break;
1236 /* u32 */
1237 case QEMU_RTA_PRIORITY:
1238 case QEMU_RTA_TABLE:
1239 case QEMU_RTA_OIF:
1240 u32 = RTA_DATA(rtattr);
1241 *u32 = tswap32(*u32);
1242 break;
1243 /* struct rta_cacheinfo */
1244 case QEMU_RTA_CACHEINFO:
1245 ci = RTA_DATA(rtattr);
1246 ci->rta_clntref = tswap32(ci->rta_clntref);
1247 ci->rta_lastuse = tswap32(ci->rta_lastuse);
1248 ci->rta_expires = tswap32(ci->rta_expires);
1249 ci->rta_error = tswap32(ci->rta_error);
1250 ci->rta_used = tswap32(ci->rta_used);
1251 #if defined(RTNETLINK_HAVE_PEERINFO)
1252 ci->rta_id = tswap32(ci->rta_id);
1253 ci->rta_ts = tswap32(ci->rta_ts);
1254 ci->rta_tsage = tswap32(ci->rta_tsage);
1255 #endif
1256 break;
1257 default:
1258 qemu_log_mask(
1259 LOG_UNIMP, "Unknown host RTA type: %d\n", rtattr->rta_type);
1260 break;
1261 }
1262 return 0;
1263 }
1264
1265 static abi_long host_to_target_data_neigh_rtattr(struct rtattr *rtattr)
1266 {
1267 struct nda_cacheinfo *ndac;
1268 uint32_t *u32;
1269
1270 switch (rtattr->rta_type) {
1271 case NDA_UNSPEC:
1272 case NDA_DST:
1273 case NDA_LLADDR:
1274 break;
1275 case NDA_PROBES:
1276 u32 = RTA_DATA(rtattr);
1277 *u32 = tswap32(*u32);
1278 break;
1279 case NDA_CACHEINFO:
1280 ndac = RTA_DATA(rtattr);
1281 ndac->ndm_confirmed = tswap32(ndac->ndm_confirmed);
1282 ndac->ndm_used = tswap32(ndac->ndm_used);
1283 ndac->ndm_updated = tswap32(ndac->ndm_updated);
1284 ndac->ndm_refcnt = tswap32(ndac->ndm_refcnt);
1285 break;
1286 default:
1287 qemu_log_mask(LOG_UNIMP, "Unknown host to target NEIGH type: %d\n",
1288 rtattr->rta_type);
1289 break;
1290 }
1291 return 0;
1292 }
1293
1294 static abi_long host_to_target_link_rtattr(struct rtattr *rtattr,
1295 uint32_t rtattr_len)
1296 {
1297 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1298 host_to_target_data_link_rtattr);
1299 }
1300
1301 static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr,
1302 uint32_t rtattr_len)
1303 {
1304 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1305 host_to_target_data_addr_rtattr);
1306 }
1307
1308 static abi_long host_to_target_route_rtattr(struct rtattr *rtattr,
1309 uint32_t rtattr_len)
1310 {
1311 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1312 host_to_target_data_route_rtattr);
1313 }
1314
1315 static abi_long host_to_target_neigh_rtattr(struct rtattr *rtattr,
1316 uint32_t rtattr_len)
1317 {
1318 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1319 host_to_target_data_neigh_rtattr);
1320 }
1321
1322 static abi_long host_to_target_data_route(struct nlmsghdr *nlh)
1323 {
1324 uint32_t nlmsg_len;
1325 struct ifinfomsg *ifi;
1326 struct ifaddrmsg *ifa;
1327 struct rtmsg *rtm;
1328 struct ndmsg *ndm;
1329
1330 nlmsg_len = nlh->nlmsg_len;
1331 switch (nlh->nlmsg_type) {
1332 case RTM_NEWLINK:
1333 case RTM_DELLINK:
1334 case RTM_GETLINK:
1335 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
1336 ifi = NLMSG_DATA(nlh);
1337 ifi->ifi_type = tswap16(ifi->ifi_type);
1338 ifi->ifi_index = tswap32(ifi->ifi_index);
1339 ifi->ifi_flags = tswap32(ifi->ifi_flags);
1340 ifi->ifi_change = tswap32(ifi->ifi_change);
1341 host_to_target_link_rtattr(IFLA_RTA(ifi),
1342 nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));
1343 }
1344 break;
1345 case RTM_NEWADDR:
1346 case RTM_DELADDR:
1347 case RTM_GETADDR:
1348 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
1349 ifa = NLMSG_DATA(nlh);
1350 ifa->ifa_index = tswap32(ifa->ifa_index);
1351 host_to_target_addr_rtattr(IFA_RTA(ifa),
1352 nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
1353 }
1354 break;
1355 case RTM_NEWNEIGH:
1356 case RTM_DELNEIGH:
1357 case RTM_GETNEIGH:
1358 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ndm))) {
1359 ndm = NLMSG_DATA(nlh);
1360 ndm->ndm_ifindex = tswap32(ndm->ndm_ifindex);
1361 ndm->ndm_state = tswap16(ndm->ndm_state);
1362 host_to_target_neigh_rtattr(NDM_RTA(ndm),
1363 nlmsg_len - NLMSG_LENGTH(sizeof(*ndm)));
1364 }
1365 break;
1366 case RTM_NEWROUTE:
1367 case RTM_DELROUTE:
1368 case RTM_GETROUTE:
1369 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
1370 rtm = NLMSG_DATA(nlh);
1371 rtm->rtm_flags = tswap32(rtm->rtm_flags);
1372 host_to_target_route_rtattr(RTM_RTA(rtm),
1373 nlmsg_len - NLMSG_LENGTH(sizeof(*rtm)));
1374 }
1375 break;
1376 default:
1377 return -TARGET_EINVAL;
1378 }
1379 return 0;
1380 }
1381
1382 static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh,
1383 size_t len)
1384 {
1385 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_route);
1386 }
1387
1388 static abi_long target_to_host_for_each_nlattr(struct nlattr *nlattr,
1389 size_t len,
1390 abi_long (*target_to_host_nlattr)
1391 (struct nlattr *))
1392 {
1393 unsigned short aligned_nla_len;
1394 abi_long ret;
1395
1396 while (len > sizeof(struct nlattr)) {
1397 if (tswap16(nlattr->nla_len) < sizeof(struct rtattr) ||
1398 tswap16(nlattr->nla_len) > len) {
1399 break;
1400 }
1401 nlattr->nla_len = tswap16(nlattr->nla_len);
1402 nlattr->nla_type = tswap16(nlattr->nla_type);
1403 ret = target_to_host_nlattr(nlattr);
1404 if (ret < 0) {
1405 return ret;
1406 }
1407
1408 aligned_nla_len = NLA_ALIGN(nlattr->nla_len);
1409 if (aligned_nla_len >= len) {
1410 break;
1411 }
1412 len -= aligned_nla_len;
1413 nlattr = (struct nlattr *)(((char *)nlattr) + aligned_nla_len);
1414 }
1415 return 0;
1416 }
1417
1418 static abi_long target_to_host_data_inet6_nlattr(struct nlattr *nlattr)
1419 {
1420 switch (nlattr->nla_type) {
1421 /* uint8_t */
1422 case QEMU_IFLA_INET6_ADDR_GEN_MODE:
1423 break;
1424 default:
1425 qemu_log_mask(LOG_UNIMP, "Unknown target AF_INET6 type: %d\n",
1426 nlattr->nla_type);
1427 }
1428 return 0;
1429 }
1430
1431 static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
1432 size_t len,
1433 abi_long (*target_to_host_rtattr)
1434 (struct rtattr *))
1435 {
1436 unsigned short aligned_rta_len;
1437 abi_long ret;
1438
1439 while (len >= sizeof(struct rtattr)) {
1440 if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) ||
1441 tswap16(rtattr->rta_len) > len) {
1442 break;
1443 }
1444 rtattr->rta_len = tswap16(rtattr->rta_len);
1445 rtattr->rta_type = tswap16(rtattr->rta_type);
1446 ret = target_to_host_rtattr(rtattr);
1447 if (ret < 0) {
1448 return ret;
1449 }
1450
1451 aligned_rta_len = RTA_ALIGN(rtattr->rta_len);
1452 if (aligned_rta_len >= len) {
1453 break;
1454 }
1455 len -= aligned_rta_len;
1456 rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
1457 }
1458 return 0;
1459 }
1460
1461 static abi_long target_to_host_data_spec_nlattr(struct nlattr *nlattr)
1462 {
1463 switch (nlattr->nla_type & NLA_TYPE_MASK) {
1464 case AF_INET6:
1465 return target_to_host_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
1466 target_to_host_data_inet6_nlattr);
1467 default:
1468 qemu_log_mask(LOG_UNIMP, "Unknown target AF_SPEC type: %d\n",
1469 nlattr->nla_type);
1470 break;
1471 }
1472 return 0;
1473 }
1474
1475 static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr)
1476 {
1477 uint32_t *u32;
1478
1479 switch (rtattr->rta_type & NLA_TYPE_MASK) {
1480 /* uint32_t */
1481 case QEMU_IFLA_MTU:
1482 case QEMU_IFLA_TXQLEN:
1483 case QEMU_IFLA_EXT_MASK:
1484 u32 = RTA_DATA(rtattr);
1485 *u32 = tswap32(*u32);
1486 break;
1487 case QEMU_IFLA_AF_SPEC:
1488 return target_to_host_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
1489 target_to_host_data_spec_nlattr);
1490 default:
1491 qemu_log_mask(LOG_UNIMP, "Unknown target QEMU_IFLA type: %d\n",
1492 rtattr->rta_type);
1493 break;
1494 }
1495 return 0;
1496 }
1497
1498 static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr)
1499 {
1500 switch (rtattr->rta_type) {
1501 /* binary: depends on family type */
1502 case QEMU_IFA_LOCAL:
1503 case QEMU_IFA_ADDRESS:
1504 break;
1505 default:
1506 qemu_log_mask(LOG_UNIMP, "Unknown target IFA type: %d\n",
1507 rtattr->rta_type);
1508 break;
1509 }
1510 return 0;
1511 }
1512
1513 static abi_long target_to_host_data_neigh_rtattr(struct rtattr *rtattr)
1514 {
1515 struct nda_cacheinfo *ndac;
1516 uint32_t *u32;
1517
1518 switch (rtattr->rta_type) {
1519 case NDA_UNSPEC:
1520 case NDA_DST:
1521 case NDA_LLADDR:
1522 break;
1523 case NDA_PROBES:
1524 u32 = RTA_DATA(rtattr);
1525 *u32 = tswap32(*u32);
1526 break;
1527 case NDA_CACHEINFO:
1528 ndac = RTA_DATA(rtattr);
1529 ndac->ndm_confirmed = tswap32(ndac->ndm_confirmed);
1530 ndac->ndm_used = tswap32(ndac->ndm_used);
1531 ndac->ndm_updated = tswap32(ndac->ndm_updated);
1532 ndac->ndm_refcnt = tswap32(ndac->ndm_refcnt);
1533 break;
1534 default:
1535 qemu_log_mask(LOG_UNIMP, "Unknown target NEIGH type: %d\n",
1536 rtattr->rta_type);
1537 break;
1538 }
1539 return 0;
1540 }
1541
1542 static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr)
1543 {
1544 uint32_t *u32;
1545 switch (rtattr->rta_type) {
1546 /* binary: depends on family type */
1547 case QEMU_RTA_DST:
1548 case QEMU_RTA_SRC:
1549 case QEMU_RTA_GATEWAY:
1550 break;
1551 /* u32 */
1552 case QEMU_RTA_PRIORITY:
1553 case QEMU_RTA_TABLE:
1554 case QEMU_RTA_OIF:
1555 u32 = RTA_DATA(rtattr);
1556 *u32 = tswap32(*u32);
1557 break;
1558 default:
1559 qemu_log_mask(LOG_UNIMP, "Unknown target RTA type: %d\n",
1560 rtattr->rta_type);
1561 break;
1562 }
1563 return 0;
1564 }
1565
1566 static void target_to_host_link_rtattr(struct rtattr *rtattr,
1567 uint32_t rtattr_len)
1568 {
1569 target_to_host_for_each_rtattr(rtattr, rtattr_len,
1570 target_to_host_data_link_rtattr);
1571 }
1572
1573 static void target_to_host_addr_rtattr(struct rtattr *rtattr,
1574 uint32_t rtattr_len)
1575 {
1576 target_to_host_for_each_rtattr(rtattr, rtattr_len,
1577 target_to_host_data_addr_rtattr);
1578 }
1579
1580 static void target_to_host_neigh_rtattr(struct rtattr *rtattr,
1581 uint32_t rtattr_len)
1582 {
1583 target_to_host_for_each_rtattr(rtattr, rtattr_len,
1584 target_to_host_data_neigh_rtattr);
1585 }
1586
1587 static void target_to_host_route_rtattr(struct rtattr *rtattr,
1588 uint32_t rtattr_len)
1589 {
1590 target_to_host_for_each_rtattr(rtattr, rtattr_len,
1591 target_to_host_data_route_rtattr);
1592 }
1593
1594 static abi_long target_to_host_data_route(struct nlmsghdr *nlh)
1595 {
1596 struct ifinfomsg *ifi;
1597 struct ifaddrmsg *ifa;
1598 struct rtmsg *rtm;
1599 struct ndmsg *ndm;
1600
1601 switch (nlh->nlmsg_type) {
1602 case RTM_NEWLINK:
1603 case RTM_DELLINK:
1604 case RTM_SETLINK:
1605 case RTM_GETLINK:
1606 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
1607 ifi = NLMSG_DATA(nlh);
1608 ifi->ifi_type = tswap16(ifi->ifi_type);
1609 ifi->ifi_index = tswap32(ifi->ifi_index);
1610 ifi->ifi_flags = tswap32(ifi->ifi_flags);
1611 ifi->ifi_change = tswap32(ifi->ifi_change);
1612 target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len -
1613 NLMSG_LENGTH(sizeof(*ifi)));
1614 }
1615 break;
1616 case RTM_GETADDR:
1617 case RTM_NEWADDR:
1618 case RTM_DELADDR:
1619 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
1620 ifa = NLMSG_DATA(nlh);
1621 ifa->ifa_index = tswap32(ifa->ifa_index);
1622 target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len -
1623 NLMSG_LENGTH(sizeof(*ifa)));
1624 }
1625 break;
1626 case RTM_NEWNEIGH:
1627 case RTM_DELNEIGH:
1628 case RTM_GETNEIGH:
1629 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ndm))) {
1630 ndm = NLMSG_DATA(nlh);
1631 ndm->ndm_ifindex = tswap32(ndm->ndm_ifindex);
1632 ndm->ndm_state = tswap16(ndm->ndm_state);
1633 target_to_host_neigh_rtattr(NDM_RTA(ndm), nlh->nlmsg_len -
1634 NLMSG_LENGTH(sizeof(*ndm)));
1635 }
1636 break;
1637 case RTM_NEWROUTE:
1638 case RTM_DELROUTE:
1639 case RTM_GETROUTE:
1640 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
1641 rtm = NLMSG_DATA(nlh);
1642 rtm->rtm_flags = tswap32(rtm->rtm_flags);
1643 target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len -
1644 NLMSG_LENGTH(sizeof(*rtm)));
1645 }
1646 break;
1647 default:
1648 return -TARGET_EOPNOTSUPP;
1649 }
1650 return 0;
1651 }
1652
1653 static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t len)
1654 {
1655 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_route);
1656 }
1657 #endif /* CONFIG_RTNETLINK */
1658
1659 static abi_long host_to_target_data_audit(struct nlmsghdr *nlh)
1660 {
1661 switch (nlh->nlmsg_type) {
1662 default:
1663 qemu_log_mask(LOG_UNIMP, "Unknown host audit message type %d\n",
1664 nlh->nlmsg_type);
1665 return -TARGET_EINVAL;
1666 }
1667 return 0;
1668 }
1669
1670 static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh,
1671 size_t len)
1672 {
1673 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_audit);
1674 }
1675
1676 static abi_long target_to_host_data_audit(struct nlmsghdr *nlh)
1677 {
1678 switch (nlh->nlmsg_type) {
1679 case AUDIT_USER:
1680 case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG:
1681 case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2:
1682 break;
1683 default:
1684 qemu_log_mask(LOG_UNIMP, "Unknown target audit message type %d\n",
1685 nlh->nlmsg_type);
1686 return -TARGET_EINVAL;
1687 }
1688
1689 return 0;
1690 }
1691
1692 static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t len)
1693 {
1694 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_audit);
1695 }
1696
1697 static abi_long packet_target_to_host_sockaddr(void *host_addr,
1698 abi_ulong target_addr,
1699 socklen_t len)
1700 {
1701 struct sockaddr *addr = host_addr;
1702 struct target_sockaddr *target_saddr;
1703
1704 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1705 if (!target_saddr) {
1706 return -TARGET_EFAULT;
1707 }
1708
1709 memcpy(addr, target_saddr, len);
1710 addr->sa_family = tswap16(target_saddr->sa_family);
1711 /* spkt_protocol is big-endian */
1712
1713 unlock_user(target_saddr, target_addr, 0);
1714 return 0;
1715 }
1716
1717 TargetFdTrans target_packet_trans = {
1718 .target_to_host_addr = packet_target_to_host_sockaddr,
1719 };
1720
1721 #ifdef CONFIG_RTNETLINK
1722 static abi_long netlink_route_target_to_host(void *buf, size_t len)
1723 {
1724 abi_long ret;
1725
1726 ret = target_to_host_nlmsg_route(buf, len);
1727 if (ret < 0) {
1728 return ret;
1729 }
1730
1731 return len;
1732 }
1733
1734 static abi_long netlink_route_host_to_target(void *buf, size_t len)
1735 {
1736 abi_long ret;
1737
1738 ret = host_to_target_nlmsg_route(buf, len);
1739 if (ret < 0) {
1740 return ret;
1741 }
1742
1743 return len;
1744 }
1745
1746 TargetFdTrans target_netlink_route_trans = {
1747 .target_to_host_data = netlink_route_target_to_host,
1748 .host_to_target_data = netlink_route_host_to_target,
1749 };
1750 #endif /* CONFIG_RTNETLINK */
1751
1752 static abi_long netlink_audit_target_to_host(void *buf, size_t len)
1753 {
1754 abi_long ret;
1755
1756 ret = target_to_host_nlmsg_audit(buf, len);
1757 if (ret < 0) {
1758 return ret;
1759 }
1760
1761 return len;
1762 }
1763
1764 static abi_long netlink_audit_host_to_target(void *buf, size_t len)
1765 {
1766 abi_long ret;
1767
1768 ret = host_to_target_nlmsg_audit(buf, len);
1769 if (ret < 0) {
1770 return ret;
1771 }
1772
1773 return len;
1774 }
1775
1776 TargetFdTrans target_netlink_audit_trans = {
1777 .target_to_host_data = netlink_audit_target_to_host,
1778 .host_to_target_data = netlink_audit_host_to_target,
1779 };
1780
1781 /* signalfd siginfo conversion */
1782
1783 static void
1784 host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo,
1785 const struct signalfd_siginfo *info)
1786 {
1787 int sig = host_to_target_signal(info->ssi_signo);
1788
1789 /* linux/signalfd.h defines a ssi_addr_lsb
1790 * not defined in sys/signalfd.h but used by some kernels
1791 */
1792
1793 #ifdef BUS_MCEERR_AO
1794 if (tinfo->ssi_signo == SIGBUS &&
1795 (tinfo->ssi_code == BUS_MCEERR_AR ||
1796 tinfo->ssi_code == BUS_MCEERR_AO)) {
1797 uint16_t *ssi_addr_lsb = (uint16_t *)(&info->ssi_addr + 1);
1798 uint16_t *tssi_addr_lsb = (uint16_t *)(&tinfo->ssi_addr + 1);
1799 *tssi_addr_lsb = tswap16(*ssi_addr_lsb);
1800 }
1801 #endif
1802
1803 tinfo->ssi_signo = tswap32(sig);
1804 tinfo->ssi_errno = tswap32(tinfo->ssi_errno);
1805 tinfo->ssi_code = tswap32(info->ssi_code);
1806 tinfo->ssi_pid = tswap32(info->ssi_pid);
1807 tinfo->ssi_uid = tswap32(info->ssi_uid);
1808 tinfo->ssi_fd = tswap32(info->ssi_fd);
1809 tinfo->ssi_tid = tswap32(info->ssi_tid);
1810 tinfo->ssi_band = tswap32(info->ssi_band);
1811 tinfo->ssi_overrun = tswap32(info->ssi_overrun);
1812 tinfo->ssi_trapno = tswap32(info->ssi_trapno);
1813 tinfo->ssi_status = tswap32(info->ssi_status);
1814 tinfo->ssi_int = tswap32(info->ssi_int);
1815 tinfo->ssi_ptr = tswap64(info->ssi_ptr);
1816 tinfo->ssi_utime = tswap64(info->ssi_utime);
1817 tinfo->ssi_stime = tswap64(info->ssi_stime);
1818 tinfo->ssi_addr = tswap64(info->ssi_addr);
1819 }
1820
1821 static abi_long host_to_target_data_signalfd(void *buf, size_t len)
1822 {
1823 int i;
1824
1825 for (i = 0; i < len; i += sizeof(struct signalfd_siginfo)) {
1826 host_to_target_signalfd_siginfo(buf + i, buf + i);
1827 }
1828
1829 return len;
1830 }
1831
1832 TargetFdTrans target_signalfd_trans = {
1833 .host_to_target_data = host_to_target_data_signalfd,
1834 };
1835
1836 static abi_long swap_data_u64(void *buf, size_t len)
1837 {
1838 uint64_t *counter = buf;
1839 int i;
1840
1841 if (len < sizeof(uint64_t)) {
1842 return -EINVAL;
1843 }
1844
1845 for (i = 0; i < len; i += sizeof(uint64_t)) {
1846 *counter = tswap64(*counter);
1847 counter++;
1848 }
1849
1850 return len;
1851 }
1852
1853 TargetFdTrans target_eventfd_trans = {
1854 .host_to_target_data = swap_data_u64,
1855 .target_to_host_data = swap_data_u64,
1856 };
1857
1858 TargetFdTrans target_timerfd_trans = {
1859 .host_to_target_data = swap_data_u64,
1860 };
1861
1862 static abi_long host_to_target_data_inotify(void *buf, size_t len)
1863 {
1864 struct inotify_event *ev;
1865 int i;
1866 uint32_t name_len;
1867
1868 for (i = 0; i < len; i += sizeof(struct inotify_event) + name_len) {
1869 ev = (struct inotify_event *)((char *)buf + i);
1870 name_len = ev->len;
1871
1872 ev->wd = tswap32(ev->wd);
1873 ev->mask = tswap32(ev->mask);
1874 ev->cookie = tswap32(ev->cookie);
1875 ev->len = tswap32(name_len);
1876 }
1877
1878 return len;
1879 }
1880
1881 TargetFdTrans target_inotify_trans = {
1882 .host_to_target_data = host_to_target_data_inotify,
1883 };