]> git.proxmox.com Git - mirror_qemu.git/blame - linux-user/fd-trans.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
linux-user: Split signal-related prototypes into signal-common.h
[mirror_qemu.git] / linux-user / fd-trans.c
CommitLineData
f7e6a401
LV		 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#ifdef CONFIG_INOTIFY
22#include <sys/inotify.h>
23#endif
24#include <linux/netlink.h>
25#ifdef CONFIG_RTNETLINK
26#include <linux/rtnetlink.h>
27#include <linux/if_bridge.h>
28#endif
29#include "qemu.h"
30#include "fd-trans.h"
2113aed6 31#include "signal-common.h"
f7e6a401
LV		 32
33enum {
34 QEMU_IFLA_BR_UNSPEC,
35 QEMU_IFLA_BR_FORWARD_DELAY,
36 QEMU_IFLA_BR_HELLO_TIME,
37 QEMU_IFLA_BR_MAX_AGE,
38 QEMU_IFLA_BR_AGEING_TIME,
39 QEMU_IFLA_BR_STP_STATE,
40 QEMU_IFLA_BR_PRIORITY,
41 QEMU_IFLA_BR_VLAN_FILTERING,
42 QEMU_IFLA_BR_VLAN_PROTOCOL,
43 QEMU_IFLA_BR_GROUP_FWD_MASK,
44 QEMU_IFLA_BR_ROOT_ID,
45 QEMU_IFLA_BR_BRIDGE_ID,
46 QEMU_IFLA_BR_ROOT_PORT,
47 QEMU_IFLA_BR_ROOT_PATH_COST,
48 QEMU_IFLA_BR_TOPOLOGY_CHANGE,
49 QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
50 QEMU_IFLA_BR_HELLO_TIMER,
51 QEMU_IFLA_BR_TCN_TIMER,
52 QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER,
53 QEMU_IFLA_BR_GC_TIMER,
54 QEMU_IFLA_BR_GROUP_ADDR,
55 QEMU_IFLA_BR_FDB_FLUSH,
56 QEMU_IFLA_BR_MCAST_ROUTER,
57 QEMU_IFLA_BR_MCAST_SNOOPING,
58 QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR,
59 QEMU_IFLA_BR_MCAST_QUERIER,
60 QEMU_IFLA_BR_MCAST_HASH_ELASTICITY,
61 QEMU_IFLA_BR_MCAST_HASH_MAX,
62 QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT,
63 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT,
64 QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL,
65 QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL,
66 QEMU_IFLA_BR_MCAST_QUERIER_INTVL,
67 QEMU_IFLA_BR_MCAST_QUERY_INTVL,
68 QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL,
69 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL,
70 QEMU_IFLA_BR_NF_CALL_IPTABLES,
71 QEMU_IFLA_BR_NF_CALL_IP6TABLES,
72 QEMU_IFLA_BR_NF_CALL_ARPTABLES,
73 QEMU_IFLA_BR_VLAN_DEFAULT_PVID,
74 QEMU_IFLA_BR_PAD,
75 QEMU_IFLA_BR_VLAN_STATS_ENABLED,
76 QEMU_IFLA_BR_MCAST_STATS_ENABLED,
77 QEMU_IFLA_BR_MCAST_IGMP_VERSION,
78 QEMU_IFLA_BR_MCAST_MLD_VERSION,
61b463fb
LV		 79 QEMU_IFLA_BR_VLAN_STATS_PER_PORT,
80 QEMU_IFLA_BR_MULTI_BOOLOPT,
f7e6a401
LV		 81 QEMU___IFLA_BR_MAX,
82};
83
84enum {
85 QEMU_IFLA_UNSPEC,
86 QEMU_IFLA_ADDRESS,
87 QEMU_IFLA_BROADCAST,
88 QEMU_IFLA_IFNAME,
89 QEMU_IFLA_MTU,
90 QEMU_IFLA_LINK,
91 QEMU_IFLA_QDISC,
92 QEMU_IFLA_STATS,
93 QEMU_IFLA_COST,
94 QEMU_IFLA_PRIORITY,
95 QEMU_IFLA_MASTER,
96 QEMU_IFLA_WIRELESS,
97 QEMU_IFLA_PROTINFO,
98 QEMU_IFLA_TXQLEN,
99 QEMU_IFLA_MAP,
100 QEMU_IFLA_WEIGHT,
101 QEMU_IFLA_OPERSTATE,
102 QEMU_IFLA_LINKMODE,
103 QEMU_IFLA_LINKINFO,
104 QEMU_IFLA_NET_NS_PID,
105 QEMU_IFLA_IFALIAS,
106 QEMU_IFLA_NUM_VF,
107 QEMU_IFLA_VFINFO_LIST,
108 QEMU_IFLA_STATS64,
109 QEMU_IFLA_VF_PORTS,
110 QEMU_IFLA_PORT_SELF,
111 QEMU_IFLA_AF_SPEC,
112 QEMU_IFLA_GROUP,
113 QEMU_IFLA_NET_NS_FD,
114 QEMU_IFLA_EXT_MASK,
115 QEMU_IFLA_PROMISCUITY,
116 QEMU_IFLA_NUM_TX_QUEUES,
117 QEMU_IFLA_NUM_RX_QUEUES,
118 QEMU_IFLA_CARRIER,
119 QEMU_IFLA_PHYS_PORT_ID,
120 QEMU_IFLA_CARRIER_CHANGES,
121 QEMU_IFLA_PHYS_SWITCH_ID,
122 QEMU_IFLA_LINK_NETNSID,
123 QEMU_IFLA_PHYS_PORT_NAME,
124 QEMU_IFLA_PROTO_DOWN,
125 QEMU_IFLA_GSO_MAX_SEGS,
126 QEMU_IFLA_GSO_MAX_SIZE,
127 QEMU_IFLA_PAD,
128 QEMU_IFLA_XDP,
129 QEMU_IFLA_EVENT,
130 QEMU_IFLA_NEW_NETNSID,
131 QEMU_IFLA_IF_NETNSID,
132 QEMU_IFLA_CARRIER_UP_COUNT,
133 QEMU_IFLA_CARRIER_DOWN_COUNT,
134 QEMU_IFLA_NEW_IFINDEX,
0f5faca7
LV		 135 QEMU_IFLA_MIN_MTU,
136 QEMU_IFLA_MAX_MTU,
d9679ee5
LV		 137 QEMU_IFLA_PROP_LIST,
138 QEMU_IFLA_ALT_IFNAME,
139 QEMU_IFLA_PERM_ADDRESS,
f7e6a401
LV		 140 QEMU___IFLA_MAX
141};
142
143enum {
144 QEMU_IFLA_BRPORT_UNSPEC,
145 QEMU_IFLA_BRPORT_STATE,
146 QEMU_IFLA_BRPORT_PRIORITY,
147 QEMU_IFLA_BRPORT_COST,
148 QEMU_IFLA_BRPORT_MODE,
149 QEMU_IFLA_BRPORT_GUARD,
150 QEMU_IFLA_BRPORT_PROTECT,
151 QEMU_IFLA_BRPORT_FAST_LEAVE,
152 QEMU_IFLA_BRPORT_LEARNING,
153 QEMU_IFLA_BRPORT_UNICAST_FLOOD,
154 QEMU_IFLA_BRPORT_PROXYARP,
155 QEMU_IFLA_BRPORT_LEARNING_SYNC,
156 QEMU_IFLA_BRPORT_PROXYARP_WIFI,
157 QEMU_IFLA_BRPORT_ROOT_ID,
158 QEMU_IFLA_BRPORT_BRIDGE_ID,
159 QEMU_IFLA_BRPORT_DESIGNATED_PORT,
160 QEMU_IFLA_BRPORT_DESIGNATED_COST,
161 QEMU_IFLA_BRPORT_ID,
162 QEMU_IFLA_BRPORT_NO,
163 QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
164 QEMU_IFLA_BRPORT_CONFIG_PENDING,
165 QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER,
166 QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER,
167 QEMU_IFLA_BRPORT_HOLD_TIMER,
168 QEMU_IFLA_BRPORT_FLUSH,
169 QEMU_IFLA_BRPORT_MULTICAST_ROUTER,
170 QEMU_IFLA_BRPORT_PAD,
171 QEMU_IFLA_BRPORT_MCAST_FLOOD,
172 QEMU_IFLA_BRPORT_MCAST_TO_UCAST,
173 QEMU_IFLA_BRPORT_VLAN_TUNNEL,
174 QEMU_IFLA_BRPORT_BCAST_FLOOD,
175 QEMU_IFLA_BRPORT_GROUP_FWD_MASK,
176 QEMU_IFLA_BRPORT_NEIGH_SUPPRESS,
0f5faca7
LV		 177 QEMU_IFLA_BRPORT_ISOLATED,
178 QEMU_IFLA_BRPORT_BACKUP_PORT,
5351f407
LV		 179 QEMU_IFLA_BRPORT_MRP_RING_OPEN,
180 QEMU_IFLA_BRPORT_MRP_IN_OPEN,
f7e6a401
LV		 181 QEMU___IFLA_BRPORT_MAX
182};
183
184enum {
185 QEMU_IFLA_TUN_UNSPEC,
186 QEMU_IFLA_TUN_OWNER,
187 QEMU_IFLA_TUN_GROUP,
188 QEMU_IFLA_TUN_TYPE,
189 QEMU_IFLA_TUN_PI,
190 QEMU_IFLA_TUN_VNET_HDR,
191 QEMU_IFLA_TUN_PERSIST,
192 QEMU_IFLA_TUN_MULTI_QUEUE,
193 QEMU_IFLA_TUN_NUM_QUEUES,
194 QEMU_IFLA_TUN_NUM_DISABLED_QUEUES,
195 QEMU___IFLA_TUN_MAX,
196};
197
198enum {
199 QEMU_IFLA_INFO_UNSPEC,
200 QEMU_IFLA_INFO_KIND,
201 QEMU_IFLA_INFO_DATA,
202 QEMU_IFLA_INFO_XSTATS,
203 QEMU_IFLA_INFO_SLAVE_KIND,
204 QEMU_IFLA_INFO_SLAVE_DATA,
205 QEMU___IFLA_INFO_MAX,
206};
207
208enum {
209 QEMU_IFLA_INET_UNSPEC,
210 QEMU_IFLA_INET_CONF,
211 QEMU___IFLA_INET_MAX,
212};
213
214enum {
215 QEMU_IFLA_INET6_UNSPEC,
216 QEMU_IFLA_INET6_FLAGS,
217 QEMU_IFLA_INET6_CONF,
218 QEMU_IFLA_INET6_STATS,
219 QEMU_IFLA_INET6_MCAST,
220 QEMU_IFLA_INET6_CACHEINFO,
221 QEMU_IFLA_INET6_ICMP6STATS,
222 QEMU_IFLA_INET6_TOKEN,
223 QEMU_IFLA_INET6_ADDR_GEN_MODE,
224 QEMU___IFLA_INET6_MAX
225};
226
227enum {
228 QEMU_IFLA_XDP_UNSPEC,
229 QEMU_IFLA_XDP_FD,
230 QEMU_IFLA_XDP_ATTACHED,
231 QEMU_IFLA_XDP_FLAGS,
232 QEMU_IFLA_XDP_PROG_ID,
233 QEMU___IFLA_XDP_MAX,
234};
235
236enum {
237 QEMU_RTA_UNSPEC,
238 QEMU_RTA_DST,
239 QEMU_RTA_SRC,
240 QEMU_RTA_IIF,
241 QEMU_RTA_OIF,
242 QEMU_RTA_GATEWAY,
243 QEMU_RTA_PRIORITY,
244 QEMU_RTA_PREFSRC,
245 QEMU_RTA_METRICS,
246 QEMU_RTA_MULTIPATH,
247 QEMU_RTA_PROTOINFO, /* no longer used */
248 QEMU_RTA_FLOW,
249 QEMU_RTA_CACHEINFO,
250 QEMU_RTA_SESSION, /* no longer used */
251 QEMU_RTA_MP_ALGO, /* no longer used */
252 QEMU_RTA_TABLE,
253 QEMU_RTA_MARK,
254 QEMU_RTA_MFC_STATS,
255 QEMU_RTA_VIA,
256 QEMU_RTA_NEWDST,
257 QEMU_RTA_PREF,
258 QEMU_RTA_ENCAP_TYPE,
259 QEMU_RTA_ENCAP,
260 QEMU_RTA_EXPIRES,
261 QEMU_RTA_PAD,
262 QEMU_RTA_UID,
263 QEMU_RTA_TTL_PROPAGATE,
264 QEMU_RTA_IP_PROTO,
265 QEMU_RTA_SPORT,
266 QEMU_RTA_DPORT,
267 QEMU___RTA_MAX
268};
269
270TargetFdTrans **target_fd_trans;
c093364f 271QemuMutex target_fd_trans_lock;
f7e6a401
LV		 272unsigned int target_fd_max;
273
274static void tswap_nlmsghdr(struct nlmsghdr *nlh)
275{
276 nlh->nlmsg_len = tswap32(nlh->nlmsg_len);
277 nlh->nlmsg_type = tswap16(nlh->nlmsg_type);
278 nlh->nlmsg_flags = tswap16(nlh->nlmsg_flags);
279 nlh->nlmsg_seq = tswap32(nlh->nlmsg_seq);
280 nlh->nlmsg_pid = tswap32(nlh->nlmsg_pid);
281}
282
283static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
284 size_t len,
285 abi_long (*host_to_target_nlmsg)
286 (struct nlmsghdr *))
287{
288 uint32_t nlmsg_len;
1645fb5a 289 uint32_t aligned_nlmsg_len;
f7e6a401
LV		 290 abi_long ret;
291
292 while (len > sizeof(struct nlmsghdr)) {
293
294 nlmsg_len = nlh->nlmsg_len;
295 if (nlmsg_len < sizeof(struct nlmsghdr) ||
296 nlmsg_len > len) {
297 break;
298 }
299
300 switch (nlh->nlmsg_type) {
301 case NLMSG_DONE:
302 tswap_nlmsghdr(nlh);
303 return 0;
304 case NLMSG_NOOP:
305 break;
306 case NLMSG_ERROR:
307 {
308 struct nlmsgerr *e = NLMSG_DATA(nlh);
309 e->error = tswap32(e->error);
310 tswap_nlmsghdr(&e->msg);
311 tswap_nlmsghdr(nlh);
312 return 0;
313 }
314 default:
315 ret = host_to_target_nlmsg(nlh);
316 if (ret < 0) {
317 tswap_nlmsghdr(nlh);
318 return ret;
319 }
320 break;
321 }
322 tswap_nlmsghdr(nlh);
1645fb5a
SCW		 323
324 aligned_nlmsg_len = NLMSG_ALIGN(nlmsg_len);
325 if (aligned_nlmsg_len >= len) {
326 break;
327 }
328 len -= aligned_nlmsg_len;
329 nlh = (struct nlmsghdr *)(((char*)nlh) + aligned_nlmsg_len);
f7e6a401
LV		 330 }
331 return 0;
332}
333
334static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
335 size_t len,
336 abi_long (*target_to_host_nlmsg)
337 (struct nlmsghdr *))
338{
1645fb5a 339 uint32_t aligned_nlmsg_len;
f7e6a401
LV		 340 int ret;
341
342 while (len > sizeof(struct nlmsghdr)) {
343 if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) ||
344 tswap32(nlh->nlmsg_len) > len) {
345 break;
346 }
347 tswap_nlmsghdr(nlh);
348 switch (nlh->nlmsg_type) {
349 case NLMSG_DONE:
350 return 0;
351 case NLMSG_NOOP:
352 break;
353 case NLMSG_ERROR:
354 {
355 struct nlmsgerr *e = NLMSG_DATA(nlh);
356 e->error = tswap32(e->error);
357 tswap_nlmsghdr(&e->msg);
358 return 0;
359 }
360 default:
361 ret = target_to_host_nlmsg(nlh);
362 if (ret < 0) {
363 return ret;
364 }
365 }
1645fb5a
SCW		 366
367 aligned_nlmsg_len = NLMSG_ALIGN(nlh->nlmsg_len);
368 if (aligned_nlmsg_len >= len) {
369 break;
370 }
371 len -= aligned_nlmsg_len;
372 nlh = (struct nlmsghdr *)(((char *)nlh) + aligned_nlmsg_len);
f7e6a401
LV		 373 }
374 return 0;
375}
376
377#ifdef CONFIG_RTNETLINK
378static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
379 size_t len, void *context,
380 abi_long (*host_to_target_nlattr)
381 (struct nlattr *,
382 void *context))
383{
384 unsigned short nla_len;
1645fb5a 385 unsigned short aligned_nla_len;
f7e6a401
LV		 386 abi_long ret;
387
388 while (len > sizeof(struct nlattr)) {
389 nla_len = nlattr->nla_len;
390 if (nla_len < sizeof(struct nlattr) ||
391 nla_len > len) {
392 break;
393 }
394 ret = host_to_target_nlattr(nlattr, context);
395 nlattr->nla_len = tswap16(nlattr->nla_len);
396 nlattr->nla_type = tswap16(nlattr->nla_type);
397 if (ret < 0) {
398 return ret;
399 }
1645fb5a
SCW		 400
401 aligned_nla_len = NLA_ALIGN(nla_len);
402 if (aligned_nla_len >= len) {
403 break;
404 }
405 len -= aligned_nla_len;
406 nlattr = (struct nlattr *)(((char *)nlattr) + aligned_nla_len);
f7e6a401
LV		 407 }
408 return 0;
409}
410
411static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
412 size_t len,
413 abi_long (*host_to_target_rtattr)
414 (struct rtattr *))
415{
416 unsigned short rta_len;
1645fb5a 417 unsigned short aligned_rta_len;
f7e6a401
LV		 418 abi_long ret;
419
420 while (len > sizeof(struct rtattr)) {
421 rta_len = rtattr->rta_len;
422 if (rta_len < sizeof(struct rtattr) ||
423 rta_len > len) {
424 break;
425 }
426 ret = host_to_target_rtattr(rtattr);
427 rtattr->rta_len = tswap16(rtattr->rta_len);
428 rtattr->rta_type = tswap16(rtattr->rta_type);
429 if (ret < 0) {
430 return ret;
431 }
1645fb5a
SCW		 432
433 aligned_rta_len = RTA_ALIGN(rta_len);
434 if (aligned_rta_len >= len) {
435 break;
436 }
437 len -= aligned_rta_len;
438 rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
f7e6a401
LV		 439 }
440 return 0;
441}
442
443#define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN)
444
445static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr,
446 void *context)
447{
448 uint16_t *u16;
449 uint32_t *u32;
450 uint64_t *u64;
451
452 switch (nlattr->nla_type) {
453 /* no data */
454 case QEMU_IFLA_BR_FDB_FLUSH:
455 break;
456 /* binary */
457 case QEMU_IFLA_BR_GROUP_ADDR:
458 break;
459 /* uint8_t */
460 case QEMU_IFLA_BR_VLAN_FILTERING:
461 case QEMU_IFLA_BR_TOPOLOGY_CHANGE:
462 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED:
463 case QEMU_IFLA_BR_MCAST_ROUTER:
464 case QEMU_IFLA_BR_MCAST_SNOOPING:
465 case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR:
466 case QEMU_IFLA_BR_MCAST_QUERIER:
467 case QEMU_IFLA_BR_NF_CALL_IPTABLES:
468 case QEMU_IFLA_BR_NF_CALL_IP6TABLES:
469 case QEMU_IFLA_BR_NF_CALL_ARPTABLES:
470 case QEMU_IFLA_BR_VLAN_STATS_ENABLED:
471 case QEMU_IFLA_BR_MCAST_STATS_ENABLED:
472 case QEMU_IFLA_BR_MCAST_IGMP_VERSION:
473 case QEMU_IFLA_BR_MCAST_MLD_VERSION:
61b463fb 474 case QEMU_IFLA_BR_VLAN_STATS_PER_PORT:
f7e6a401
LV		 475 break;
476 /* uint16_t */
477 case QEMU_IFLA_BR_PRIORITY:
478 case QEMU_IFLA_BR_VLAN_PROTOCOL:
479 case QEMU_IFLA_BR_GROUP_FWD_MASK:
480 case QEMU_IFLA_BR_ROOT_PORT:
481 case QEMU_IFLA_BR_VLAN_DEFAULT_PVID:
482 u16 = NLA_DATA(nlattr);
483 *u16 = tswap16(*u16);
484 break;
485 /* uint32_t */
486 case QEMU_IFLA_BR_FORWARD_DELAY:
487 case QEMU_IFLA_BR_HELLO_TIME:
488 case QEMU_IFLA_BR_MAX_AGE:
489 case QEMU_IFLA_BR_AGEING_TIME:
490 case QEMU_IFLA_BR_STP_STATE:
491 case QEMU_IFLA_BR_ROOT_PATH_COST:
492 case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY:
493 case QEMU_IFLA_BR_MCAST_HASH_MAX:
494 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT:
495 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT:
496 u32 = NLA_DATA(nlattr);
497 *u32 = tswap32(*u32);
498 break;
499 /* uint64_t */
500 case QEMU_IFLA_BR_HELLO_TIMER:
501 case QEMU_IFLA_BR_TCN_TIMER:
502 case QEMU_IFLA_BR_GC_TIMER:
503 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER:
504 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL:
505 case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL:
506 case QEMU_IFLA_BR_MCAST_QUERIER_INTVL:
507 case QEMU_IFLA_BR_MCAST_QUERY_INTVL:
508 case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL:
509 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL:
510 u64 = NLA_DATA(nlattr);
511 *u64 = tswap64(*u64);
512 break;
513 /* ifla_bridge_id: uin8_t[] */
514 case QEMU_IFLA_BR_ROOT_ID:
515 case QEMU_IFLA_BR_BRIDGE_ID:
516 break;
01154f79
LV		 517 /* br_boolopt_multi { uint32_t, uint32_t } */
518 case QEMU_IFLA_BR_MULTI_BOOLOPT:
519 u32 = NLA_DATA(nlattr);
520 u32[0] = tswap32(u32[0]); /* optval */
521 u32[1] = tswap32(u32[1]); /* optmask */
522 break;
f7e6a401 523 default:
39be5350
JK		 524 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_BR type %d\n",
525 nlattr->nla_type);
f7e6a401
LV		 526 break;
527 }
528 return 0;
529}
530
531static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nlattr,
532 void *context)
533{
534 uint16_t *u16;
535 uint32_t *u32;
536 uint64_t *u64;
537
538 switch (nlattr->nla_type) {
539 /* uint8_t */
540 case QEMU_IFLA_BRPORT_STATE:
541 case QEMU_IFLA_BRPORT_MODE:
542 case QEMU_IFLA_BRPORT_GUARD:
543 case QEMU_IFLA_BRPORT_PROTECT:
544 case QEMU_IFLA_BRPORT_FAST_LEAVE:
545 case QEMU_IFLA_BRPORT_LEARNING:
546 case QEMU_IFLA_BRPORT_UNICAST_FLOOD:
547 case QEMU_IFLA_BRPORT_PROXYARP:
548 case QEMU_IFLA_BRPORT_LEARNING_SYNC:
549 case QEMU_IFLA_BRPORT_PROXYARP_WIFI:
550 case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK:
551 case QEMU_IFLA_BRPORT_CONFIG_PENDING:
552 case QEMU_IFLA_BRPORT_MULTICAST_ROUTER:
553 case QEMU_IFLA_BRPORT_MCAST_FLOOD:
554 case QEMU_IFLA_BRPORT_MCAST_TO_UCAST:
555 case QEMU_IFLA_BRPORT_VLAN_TUNNEL:
556 case QEMU_IFLA_BRPORT_BCAST_FLOOD:
557 case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS:
0f5faca7 558 case QEMU_IFLA_BRPORT_ISOLATED:
5351f407
LV		 559 case QEMU_IFLA_BRPORT_MRP_RING_OPEN:
560 case QEMU_IFLA_BRPORT_MRP_IN_OPEN:
f7e6a401
LV		 561 break;
562 /* uint16_t */
563 case QEMU_IFLA_BRPORT_PRIORITY:
564 case QEMU_IFLA_BRPORT_DESIGNATED_PORT:
565 case QEMU_IFLA_BRPORT_DESIGNATED_COST:
566 case QEMU_IFLA_BRPORT_ID:
567 case QEMU_IFLA_BRPORT_NO:
568 case QEMU_IFLA_BRPORT_GROUP_FWD_MASK:
569 u16 = NLA_DATA(nlattr);
570 *u16 = tswap16(*u16);
571 break;
572 /* uin32_t */
573 case QEMU_IFLA_BRPORT_COST:
0f5faca7 574 case QEMU_IFLA_BRPORT_BACKUP_PORT:
f7e6a401
LV		 575 u32 = NLA_DATA(nlattr);
576 *u32 = tswap32(*u32);
577 break;
578 /* uint64_t */
579 case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER:
580 case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER:
581 case QEMU_IFLA_BRPORT_HOLD_TIMER:
582 u64 = NLA_DATA(nlattr);
583 *u64 = tswap64(*u64);
584 break;
585 /* ifla_bridge_id: uint8_t[] */
586 case QEMU_IFLA_BRPORT_ROOT_ID:
587 case QEMU_IFLA_BRPORT_BRIDGE_ID:
588 break;
589 default:
39be5350
JK		 590 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_BRPORT type %d\n",
591 nlattr->nla_type);
f7e6a401
LV		 592 break;
593 }
594 return 0;
595}
596
597static abi_long host_to_target_data_tun_nlattr(struct nlattr *nlattr,
598 void *context)
599{
600 uint32_t *u32;
601
602 switch (nlattr->nla_type) {
603 /* uint8_t */
604 case QEMU_IFLA_TUN_TYPE:
605 case QEMU_IFLA_TUN_PI:
606 case QEMU_IFLA_TUN_VNET_HDR:
607 case QEMU_IFLA_TUN_PERSIST:
608 case QEMU_IFLA_TUN_MULTI_QUEUE:
609 break;
610 /* uint32_t */
611 case QEMU_IFLA_TUN_NUM_QUEUES:
612 case QEMU_IFLA_TUN_NUM_DISABLED_QUEUES:
613 case QEMU_IFLA_TUN_OWNER:
614 case QEMU_IFLA_TUN_GROUP:
615 u32 = NLA_DATA(nlattr);
616 *u32 = tswap32(*u32);
617 break;
618 default:
39be5350
JK		 619 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_TUN type %d\n",
620 nlattr->nla_type);
f7e6a401
LV		 621 break;
622 }
623 return 0;
624}
625
626struct linkinfo_context {
627 int len;
628 char *name;
629 int slave_len;
630 char *slave_name;
631};
632
633static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr,
634 void *context)
635{
636 struct linkinfo_context *li_context = context;
637
638 switch (nlattr->nla_type) {
639 /* string */
640 case QEMU_IFLA_INFO_KIND:
641 li_context->name = NLA_DATA(nlattr);
642 li_context->len = nlattr->nla_len - NLA_HDRLEN;
643 break;
644 case QEMU_IFLA_INFO_SLAVE_KIND:
645 li_context->slave_name = NLA_DATA(nlattr);
646 li_context->slave_len = nlattr->nla_len - NLA_HDRLEN;
647 break;
648 /* stats */
649 case QEMU_IFLA_INFO_XSTATS:
650 /* FIXME: only used by CAN */
651 break;
652 /* nested */
653 case QEMU_IFLA_INFO_DATA:
654 if (strncmp(li_context->name, "bridge",
655 li_context->len) == 0) {
656 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
657 nlattr->nla_len,
658 NULL,
659 host_to_target_data_bridge_nlattr);
660 } else if (strncmp(li_context->name, "tun",
661 li_context->len) == 0) {
662 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
663 nlattr->nla_len,
664 NULL,
665 host_to_target_data_tun_nlattr);
666 } else {
39be5350
JK		 667 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_INFO_KIND %s\n",
668 li_context->name);
f7e6a401
LV		 669 }
670 break;
671 case QEMU_IFLA_INFO_SLAVE_DATA:
672 if (strncmp(li_context->slave_name, "bridge",
673 li_context->slave_len) == 0) {
674 return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
675 nlattr->nla_len,
676 NULL,
677 host_to_target_slave_data_bridge_nlattr);
678 } else {
39be5350 679 qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n",
f7e6a401
LV		 680 li_context->slave_name);
681 }
682 break;
683 default:
39be5350
JK		 684 qemu_log_mask(LOG_UNIMP, "Unknown host QEMU_IFLA_INFO type: %d\n",
685 nlattr->nla_type);
f7e6a401
LV		 686 break;
687 }
688
689 return 0;
690}
691
692static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr,
693 void *context)
694{
695 uint32_t *u32;
696 int i;
697
698 switch (nlattr->nla_type) {
699 case QEMU_IFLA_INET_CONF:
700 u32 = NLA_DATA(nlattr);
701 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
702 i++) {
703 u32[i] = tswap32(u32[i]);
704 }
705 break;
706 default:
39be5350
JK		 707 qemu_log_mask(LOG_UNIMP, "Unknown host AF_INET type: %d\n",
708 nlattr->nla_type);
f7e6a401
LV		 709 }
710 return 0;
711}
712
713static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr,
714 void *context)
715{
716 uint32_t *u32;
717 uint64_t *u64;
718 struct ifla_cacheinfo *ci;
719 int i;
720
721 switch (nlattr->nla_type) {
722 /* binaries */
723 case QEMU_IFLA_INET6_TOKEN:
724 break;
725 /* uint8_t */
726 case QEMU_IFLA_INET6_ADDR_GEN_MODE:
727 break;
728 /* uint32_t */
729 case QEMU_IFLA_INET6_FLAGS:
730 u32 = NLA_DATA(nlattr);
731 *u32 = tswap32(*u32);
732 break;
733 /* uint32_t[] */
734 case QEMU_IFLA_INET6_CONF:
735 u32 = NLA_DATA(nlattr);
736 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
737 i++) {
738 u32[i] = tswap32(u32[i]);
739 }
740 break;
741 /* ifla_cacheinfo */
742 case QEMU_IFLA_INET6_CACHEINFO:
743 ci = NLA_DATA(nlattr);
744 ci->max_reasm_len = tswap32(ci->max_reasm_len);
745 ci->tstamp = tswap32(ci->tstamp);
746 ci->reachable_time = tswap32(ci->reachable_time);
747 ci->retrans_time = tswap32(ci->retrans_time);
748 break;
749 /* uint64_t[] */
750 case QEMU_IFLA_INET6_STATS:
751 case QEMU_IFLA_INET6_ICMP6STATS:
752 u64 = NLA_DATA(nlattr);
753 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64);
754 i++) {
755 u64[i] = tswap64(u64[i]);
756 }
757 break;
758 default:
39be5350
JK		 759 qemu_log_mask(LOG_UNIMP, "Unknown host AF_INET6 type: %d\n",
760 nlattr->nla_type);
f7e6a401
LV		 761 }
762 return 0;
763}
764
765static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr,
766 void *context)
767{
768 switch (nlattr->nla_type) {
769 case AF_INET:
770 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
771 NULL,
772 host_to_target_data_inet_nlattr);
773 case AF_INET6:
774 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
775 NULL,
776 host_to_target_data_inet6_nlattr);
777 default:
39be5350
JK		 778 qemu_log_mask(LOG_UNIMP, "Unknown host AF_SPEC type: %d\n",
779 nlattr->nla_type);
f7e6a401
LV		 780 break;
781 }
782 return 0;
783}
784
785static abi_long host_to_target_data_xdp_nlattr(struct nlattr *nlattr,
786 void *context)
787{
788 uint32_t *u32;
789
790 switch (nlattr->nla_type) {
791 /* uint8_t */
792 case QEMU_IFLA_XDP_ATTACHED:
793 break;
794 /* uint32_t */
795 case QEMU_IFLA_XDP_PROG_ID:
796 u32 = NLA_DATA(nlattr);
797 *u32 = tswap32(*u32);
798 break;
799 default:
39be5350
JK		 800 qemu_log_mask(
801 LOG_UNIMP, "Unknown host XDP type: %d\n", nlattr->nla_type);
f7e6a401
LV		 802 break;
803 }
804 return 0;
805}
806
807static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr)
808{
809 uint32_t *u32;
810 struct rtnl_link_stats *st;
811 struct rtnl_link_stats64 *st64;
812 struct rtnl_link_ifmap *map;
813 struct linkinfo_context li_context;
814
815 switch (rtattr->rta_type) {
816 /* binary stream */
817 case QEMU_IFLA_ADDRESS:
818 case QEMU_IFLA_BROADCAST:
d9679ee5 819 case QEMU_IFLA_PERM_ADDRESS:
f7e6a401
LV		 820 /* string */
821 case QEMU_IFLA_IFNAME:
822 case QEMU_IFLA_QDISC:
823 break;
824 /* uin8_t */
825 case QEMU_IFLA_OPERSTATE:
826 case QEMU_IFLA_LINKMODE:
827 case QEMU_IFLA_CARRIER:
828 case QEMU_IFLA_PROTO_DOWN:
829 break;
830 /* uint32_t */
831 case QEMU_IFLA_MTU:
832 case QEMU_IFLA_LINK:
833 case QEMU_IFLA_WEIGHT:
834 case QEMU_IFLA_TXQLEN:
835 case QEMU_IFLA_CARRIER_CHANGES:
836 case QEMU_IFLA_NUM_RX_QUEUES:
837 case QEMU_IFLA_NUM_TX_QUEUES:
838 case QEMU_IFLA_PROMISCUITY:
839 case QEMU_IFLA_EXT_MASK:
840 case QEMU_IFLA_LINK_NETNSID:
841 case QEMU_IFLA_GROUP:
842 case QEMU_IFLA_MASTER:
843 case QEMU_IFLA_NUM_VF:
844 case QEMU_IFLA_GSO_MAX_SEGS:
845 case QEMU_IFLA_GSO_MAX_SIZE:
846 case QEMU_IFLA_CARRIER_UP_COUNT:
847 case QEMU_IFLA_CARRIER_DOWN_COUNT:
0f5faca7
LV		 848 case QEMU_IFLA_MIN_MTU:
849 case QEMU_IFLA_MAX_MTU:
f7e6a401
LV		 850 u32 = RTA_DATA(rtattr);
851 *u32 = tswap32(*u32);
852 break;
853 /* struct rtnl_link_stats */
854 case QEMU_IFLA_STATS:
855 st = RTA_DATA(rtattr);
856 st->rx_packets = tswap32(st->rx_packets);
857 st->tx_packets = tswap32(st->tx_packets);
858 st->rx_bytes = tswap32(st->rx_bytes);
859 st->tx_bytes = tswap32(st->tx_bytes);
860 st->rx_errors = tswap32(st->rx_errors);
861 st->tx_errors = tswap32(st->tx_errors);
862 st->rx_dropped = tswap32(st->rx_dropped);
863 st->tx_dropped = tswap32(st->tx_dropped);
864 st->multicast = tswap32(st->multicast);
865 st->collisions = tswap32(st->collisions);
866
867 /* detailed rx_errors: */
868 st->rx_length_errors = tswap32(st->rx_length_errors);
869 st->rx_over_errors = tswap32(st->rx_over_errors);
870 st->rx_crc_errors = tswap32(st->rx_crc_errors);
871 st->rx_frame_errors = tswap32(st->rx_frame_errors);
872 st->rx_fifo_errors = tswap32(st->rx_fifo_errors);
873 st->rx_missed_errors = tswap32(st->rx_missed_errors);
874
875 /* detailed tx_errors */
876 st->tx_aborted_errors = tswap32(st->tx_aborted_errors);
877 st->tx_carrier_errors = tswap32(st->tx_carrier_errors);
878 st->tx_fifo_errors = tswap32(st->tx_fifo_errors);
879 st->tx_heartbeat_errors = tswap32(st->tx_heartbeat_errors);
880 st->tx_window_errors = tswap32(st->tx_window_errors);
881
882 /* for cslip etc */
883 st->rx_compressed = tswap32(st->rx_compressed);
884 st->tx_compressed = tswap32(st->tx_compressed);
885 break;
886 /* struct rtnl_link_stats64 */
887 case QEMU_IFLA_STATS64:
888 st64 = RTA_DATA(rtattr);
889 st64->rx_packets = tswap64(st64->rx_packets);
890 st64->tx_packets = tswap64(st64->tx_packets);
891 st64->rx_bytes = tswap64(st64->rx_bytes);
892 st64->tx_bytes = tswap64(st64->tx_bytes);
893 st64->rx_errors = tswap64(st64->rx_errors);
894 st64->tx_errors = tswap64(st64->tx_errors);
895 st64->rx_dropped = tswap64(st64->rx_dropped);
896 st64->tx_dropped = tswap64(st64->tx_dropped);
897 st64->multicast = tswap64(st64->multicast);
898 st64->collisions = tswap64(st64->collisions);
899
900 /* detailed rx_errors: */
901 st64->rx_length_errors = tswap64(st64->rx_length_errors);
902 st64->rx_over_errors = tswap64(st64->rx_over_errors);
903 st64->rx_crc_errors = tswap64(st64->rx_crc_errors);
904 st64->rx_frame_errors = tswap64(st64->rx_frame_errors);
905 st64->rx_fifo_errors = tswap64(st64->rx_fifo_errors);
906 st64->rx_missed_errors = tswap64(st64->rx_missed_errors);
907
908 /* detailed tx_errors */
909 st64->tx_aborted_errors = tswap64(st64->tx_aborted_errors);
910 st64->tx_carrier_errors = tswap64(st64->tx_carrier_errors);
911 st64->tx_fifo_errors = tswap64(st64->tx_fifo_errors);
912 st64->tx_heartbeat_errors = tswap64(st64->tx_heartbeat_errors);
913 st64->tx_window_errors = tswap64(st64->tx_window_errors);
914
915 /* for cslip etc */
916 st64->rx_compressed = tswap64(st64->rx_compressed);
917 st64->tx_compressed = tswap64(st64->tx_compressed);
918 break;
919 /* struct rtnl_link_ifmap */
920 case QEMU_IFLA_MAP:
921 map = RTA_DATA(rtattr);
922 map->mem_start = tswap64(map->mem_start);
923 map->mem_end = tswap64(map->mem_end);
924 map->base_addr = tswap64(map->base_addr);
925 map->irq = tswap16(map->irq);
926 break;
927 /* nested */
928 case QEMU_IFLA_LINKINFO:
929 memset(&li_context, 0, sizeof(li_context));
930 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
931 &li_context,
932 host_to_target_data_linkinfo_nlattr);
933 case QEMU_IFLA_AF_SPEC:
934 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
935 NULL,
936 host_to_target_data_spec_nlattr);
937 case QEMU_IFLA_XDP:
938 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
939 NULL,
940 host_to_target_data_xdp_nlattr);
941 default:
39be5350
JK		 942 qemu_log_mask(LOG_UNIMP, "Unknown host QEMU_IFLA type: %d\n",
943 rtattr->rta_type);
f7e6a401
LV		 944 break;
945 }
946 return 0;
947}
948
949static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr)
950{
951 uint32_t *u32;
952 struct ifa_cacheinfo *ci;
953
954 switch (rtattr->rta_type) {
955 /* binary: depends on family type */
956 case IFA_ADDRESS:
957 case IFA_LOCAL:
958 break;
959 /* string */
960 case IFA_LABEL:
961 break;
962 /* u32 */
963 case IFA_FLAGS:
964 case IFA_BROADCAST:
965 u32 = RTA_DATA(rtattr);
966 *u32 = tswap32(*u32);
967 break;
968 /* struct ifa_cacheinfo */
969 case IFA_CACHEINFO:
970 ci = RTA_DATA(rtattr);
971 ci->ifa_prefered = tswap32(ci->ifa_prefered);
972 ci->ifa_valid = tswap32(ci->ifa_valid);
973 ci->cstamp = tswap32(ci->cstamp);
974 ci->tstamp = tswap32(ci->tstamp);
975 break;
976 default:
39be5350
JK		 977 qemu_log_mask(
978 LOG_UNIMP, "Unknown host IFA type: %d\n", rtattr->rta_type);
f7e6a401
LV		 979 break;
980 }
981 return 0;
982}
983
984static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr)
985{
986 uint32_t *u32;
987 struct rta_cacheinfo *ci;
988
989 switch (rtattr->rta_type) {
990 /* binary: depends on family type */
991 case QEMU_RTA_GATEWAY:
992 case QEMU_RTA_DST:
993 case QEMU_RTA_PREFSRC:
994 break;
995 /* u8 */
996 case QEMU_RTA_PREF:
997 break;
998 /* u32 */
999 case QEMU_RTA_PRIORITY:
1000 case QEMU_RTA_TABLE:
1001 case QEMU_RTA_OIF:
1002 u32 = RTA_DATA(rtattr);
1003 *u32 = tswap32(*u32);
1004 break;
1005 /* struct rta_cacheinfo */
1006 case QEMU_RTA_CACHEINFO:
1007 ci = RTA_DATA(rtattr);
1008 ci->rta_clntref = tswap32(ci->rta_clntref);
1009 ci->rta_lastuse = tswap32(ci->rta_lastuse);
1010 ci->rta_expires = tswap32(ci->rta_expires);
1011 ci->rta_error = tswap32(ci->rta_error);
1012 ci->rta_used = tswap32(ci->rta_used);
1013#if defined(RTNETLINK_HAVE_PEERINFO)
1014 ci->rta_id = tswap32(ci->rta_id);
1015 ci->rta_ts = tswap32(ci->rta_ts);
1016 ci->rta_tsage = tswap32(ci->rta_tsage);
1017#endif
1018 break;
1019 default:
39be5350
JK		 1020 qemu_log_mask(
1021 LOG_UNIMP, "Unknown host RTA type: %d\n", rtattr->rta_type);
f7e6a401
LV		 1022 break;
1023 }
1024 return 0;
1025}
1026
1027static abi_long host_to_target_link_rtattr(struct rtattr *rtattr,
1028 uint32_t rtattr_len)
1029{
1030 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1031 host_to_target_data_link_rtattr);
1032}
1033
1034static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr,
1035 uint32_t rtattr_len)
1036{
1037 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1038 host_to_target_data_addr_rtattr);
1039}
1040
1041static abi_long host_to_target_route_rtattr(struct rtattr *rtattr,
1042 uint32_t rtattr_len)
1043{
1044 return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1045 host_to_target_data_route_rtattr);
1046}
1047
1048static abi_long host_to_target_data_route(struct nlmsghdr *nlh)
1049{
1050 uint32_t nlmsg_len;
1051 struct ifinfomsg *ifi;
1052 struct ifaddrmsg *ifa;
1053 struct rtmsg *rtm;
1054
1055 nlmsg_len = nlh->nlmsg_len;
1056 switch (nlh->nlmsg_type) {
1057 case RTM_NEWLINK:
1058 case RTM_DELLINK:
1059 case RTM_GETLINK:
1060 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
1061 ifi = NLMSG_DATA(nlh);
1062 ifi->ifi_type = tswap16(ifi->ifi_type);
1063 ifi->ifi_index = tswap32(ifi->ifi_index);
1064 ifi->ifi_flags = tswap32(ifi->ifi_flags);
1065 ifi->ifi_change = tswap32(ifi->ifi_change);
1066 host_to_target_link_rtattr(IFLA_RTA(ifi),
1067 nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));
1068 }
1069 break;
1070 case RTM_NEWADDR:
1071 case RTM_DELADDR:
1072 case RTM_GETADDR:
1073 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
1074 ifa = NLMSG_DATA(nlh);
1075 ifa->ifa_index = tswap32(ifa->ifa_index);
1076 host_to_target_addr_rtattr(IFA_RTA(ifa),
1077 nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
1078 }
1079 break;
1080 case RTM_NEWROUTE:
1081 case RTM_DELROUTE:
1082 case RTM_GETROUTE:
1083 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
1084 rtm = NLMSG_DATA(nlh);
1085 rtm->rtm_flags = tswap32(rtm->rtm_flags);
1086 host_to_target_route_rtattr(RTM_RTA(rtm),
1087 nlmsg_len - NLMSG_LENGTH(sizeof(*rtm)));
1088 }
1089 break;
1090 default:
1091 return -TARGET_EINVAL;
1092 }
1093 return 0;
1094}
1095
1096static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh,
1097 size_t len)
1098{
1099 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_route);
1100}
1101
1102static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
1103 size_t len,
1104 abi_long (*target_to_host_rtattr)
1105 (struct rtattr *))
1106{
1645fb5a 1107 unsigned short aligned_rta_len;
f7e6a401
LV		 1108 abi_long ret;
1109
1110 while (len >= sizeof(struct rtattr)) {
1111 if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) ||
1112 tswap16(rtattr->rta_len) > len) {
1113 break;
1114 }
1115 rtattr->rta_len = tswap16(rtattr->rta_len);
1116 rtattr->rta_type = tswap16(rtattr->rta_type);
1117 ret = target_to_host_rtattr(rtattr);
1118 if (ret < 0) {
1119 return ret;
1120 }
1645fb5a
SCW		 1121
1122 aligned_rta_len = RTA_ALIGN(rtattr->rta_len);
1123 if (aligned_rta_len >= len) {
1124 break;
1125 }
1126 len -= aligned_rta_len;
1127 rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
f7e6a401
LV		 1128 }
1129 return 0;
1130}
1131
1132static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr)
1133{
5351f407
LV		 1134 uint32_t *u32;
1135
f7e6a401 1136 switch (rtattr->rta_type) {
5351f407
LV		 1137 /* uint32_t */
1138 case QEMU_IFLA_EXT_MASK:
1139 u32 = RTA_DATA(rtattr);
1140 *u32 = tswap32(*u32);
1141 break;
f7e6a401 1142 default:
39be5350
JK		 1143 qemu_log_mask(LOG_UNIMP, "Unknown target QEMU_IFLA type: %d\n",
1144 rtattr->rta_type);
f7e6a401
LV		 1145 break;
1146 }
1147 return 0;
1148}
1149
1150static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr)
1151{
1152 switch (rtattr->rta_type) {
1153 /* binary: depends on family type */
1154 case IFA_LOCAL:
1155 case IFA_ADDRESS:
1156 break;
1157 default:
39be5350
JK		 1158 qemu_log_mask(LOG_UNIMP, "Unknown target IFA type: %d\n",
1159 rtattr->rta_type);
f7e6a401
LV		 1160 break;
1161 }
1162 return 0;
1163}
1164
1165static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr)
1166{
1167 uint32_t *u32;
1168 switch (rtattr->rta_type) {
1169 /* binary: depends on family type */
1170 case QEMU_RTA_DST:
1171 case QEMU_RTA_SRC:
1172 case QEMU_RTA_GATEWAY:
1173 break;
1174 /* u32 */
1175 case QEMU_RTA_PRIORITY:
f536612d 1176 case QEMU_RTA_TABLE:
f7e6a401
LV		 1177 case QEMU_RTA_OIF:
1178 u32 = RTA_DATA(rtattr);
1179 *u32 = tswap32(*u32);
1180 break;
1181 default:
39be5350
JK		 1182 qemu_log_mask(LOG_UNIMP, "Unknown target RTA type: %d\n",
1183 rtattr->rta_type);
f7e6a401
LV		 1184 break;
1185 }
1186 return 0;
1187}
1188
1189static void target_to_host_link_rtattr(struct rtattr *rtattr,
1190 uint32_t rtattr_len)
1191{
1192 target_to_host_for_each_rtattr(rtattr, rtattr_len,
1193 target_to_host_data_link_rtattr);
1194}
1195
1196static void target_to_host_addr_rtattr(struct rtattr *rtattr,
1197 uint32_t rtattr_len)
1198{
1199 target_to_host_for_each_rtattr(rtattr, rtattr_len,
1200 target_to_host_data_addr_rtattr);
1201}
1202
1203static void target_to_host_route_rtattr(struct rtattr *rtattr,
1204 uint32_t rtattr_len)
1205{
1206 target_to_host_for_each_rtattr(rtattr, rtattr_len,
1207 target_to_host_data_route_rtattr);
1208}
1209
1210static abi_long target_to_host_data_route(struct nlmsghdr *nlh)
1211{
1212 struct ifinfomsg *ifi;
1213 struct ifaddrmsg *ifa;
1214 struct rtmsg *rtm;
1215
1216 switch (nlh->nlmsg_type) {
f7e6a401
LV		 1217 case RTM_NEWLINK:
1218 case RTM_DELLINK:
65b261a6 1219 case RTM_SETLINK:
f536612d 1220 case RTM_GETLINK:
f7e6a401
LV		 1221 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
1222 ifi = NLMSG_DATA(nlh);
1223 ifi->ifi_type = tswap16(ifi->ifi_type);
1224 ifi->ifi_index = tswap32(ifi->ifi_index);
1225 ifi->ifi_flags = tswap32(ifi->ifi_flags);
1226 ifi->ifi_change = tswap32(ifi->ifi_change);
1227 target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len -
1228 NLMSG_LENGTH(sizeof(*ifi)));
1229 }
1230 break;
1231 case RTM_GETADDR:
1232 case RTM_NEWADDR:
1233 case RTM_DELADDR:
1234 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
1235 ifa = NLMSG_DATA(nlh);
1236 ifa->ifa_index = tswap32(ifa->ifa_index);
1237 target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len -
1238 NLMSG_LENGTH(sizeof(*ifa)));
1239 }
1240 break;
f7e6a401
LV		 1241 case RTM_NEWROUTE:
1242 case RTM_DELROUTE:
f536612d 1243 case RTM_GETROUTE:
f7e6a401
LV		 1244 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
1245 rtm = NLMSG_DATA(nlh);
1246 rtm->rtm_flags = tswap32(rtm->rtm_flags);
1247 target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len -
1248 NLMSG_LENGTH(sizeof(*rtm)));
1249 }
1250 break;
1251 default:
1252 return -TARGET_EOPNOTSUPP;
1253 }
1254 return 0;
1255}
1256
1257static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t len)
1258{
1259 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_route);
1260}
1261#endif /* CONFIG_RTNETLINK */
1262
1263static abi_long host_to_target_data_audit(struct nlmsghdr *nlh)
1264{
1265 switch (nlh->nlmsg_type) {
1266 default:
39be5350
JK		 1267 qemu_log_mask(LOG_UNIMP, "Unknown host audit message type %d\n",
1268 nlh->nlmsg_type);
f7e6a401
LV		 1269 return -TARGET_EINVAL;
1270 }
1271 return 0;
1272}
1273
1274static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh,
1275 size_t len)
1276{
1277 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_audit);
1278}
1279
1280static abi_long target_to_host_data_audit(struct nlmsghdr *nlh)
1281{
1282 switch (nlh->nlmsg_type) {
1283 case AUDIT_USER:
1284 case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG:
1285 case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2:
1286 break;
1287 default:
39be5350
JK		 1288 qemu_log_mask(LOG_UNIMP, "Unknown target audit message type %d\n",
1289 nlh->nlmsg_type);
f7e6a401
LV		 1290 return -TARGET_EINVAL;
1291 }
1292
1293 return 0;
1294}
1295
1296static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t len)
1297{
1298 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_audit);
1299}
1300
1301static abi_long packet_target_to_host_sockaddr(void *host_addr,
1302 abi_ulong target_addr,
1303 socklen_t len)
1304{
1305 struct sockaddr *addr = host_addr;
1306 struct target_sockaddr *target_saddr;
1307
1308 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1309 if (!target_saddr) {
1310 return -TARGET_EFAULT;
1311 }
1312
1313 memcpy(addr, target_saddr, len);
1314 addr->sa_family = tswap16(target_saddr->sa_family);
1315 /* spkt_protocol is big-endian */
1316
1317 unlock_user(target_saddr, target_addr, 0);
1318 return 0;
1319}
1320
1321TargetFdTrans target_packet_trans = {
1322 .target_to_host_addr = packet_target_to_host_sockaddr,
1323};
1324
1325#ifdef CONFIG_RTNETLINK
1326static abi_long netlink_route_target_to_host(void *buf, size_t len)
1327{
1328 abi_long ret;
1329
1330 ret = target_to_host_nlmsg_route(buf, len);
1331 if (ret < 0) {
1332 return ret;
1333 }
1334
1335 return len;
1336}
1337
1338static abi_long netlink_route_host_to_target(void *buf, size_t len)
1339{
1340 abi_long ret;
1341
1342 ret = host_to_target_nlmsg_route(buf, len);
1343 if (ret < 0) {
1344 return ret;
1345 }
1346
1347 return len;
1348}
1349
1350TargetFdTrans target_netlink_route_trans = {
1351 .target_to_host_data = netlink_route_target_to_host,
1352 .host_to_target_data = netlink_route_host_to_target,
1353};
1354#endif /* CONFIG_RTNETLINK */
1355
1356static abi_long netlink_audit_target_to_host(void *buf, size_t len)
1357{
1358 abi_long ret;
1359
1360 ret = target_to_host_nlmsg_audit(buf, len);
1361 if (ret < 0) {
1362 return ret;
1363 }
1364
1365 return len;
1366}
1367
1368static abi_long netlink_audit_host_to_target(void *buf, size_t len)
1369{
1370 abi_long ret;
1371
1372 ret = host_to_target_nlmsg_audit(buf, len);
1373 if (ret < 0) {
1374 return ret;
1375 }
1376
1377 return len;
1378}
1379
1380TargetFdTrans target_netlink_audit_trans = {
1381 .target_to_host_data = netlink_audit_target_to_host,
1382 .host_to_target_data = netlink_audit_host_to_target,
1383};
1384
1385/* signalfd siginfo conversion */
1386
1387static void
1388host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo,
1389 const struct signalfd_siginfo *info)
1390{
1391 int sig = host_to_target_signal(info->ssi_signo);
1392
1393 /* linux/signalfd.h defines a ssi_addr_lsb
1394 * not defined in sys/signalfd.h but used by some kernels
1395 */
1396
1397#ifdef BUS_MCEERR_AO
1398 if (tinfo->ssi_signo == SIGBUS &&
1399 (tinfo->ssi_code == BUS_MCEERR_AR ||
1400 tinfo->ssi_code == BUS_MCEERR_AO)) {
1401 uint16_t *ssi_addr_lsb = (uint16_t *)(&info->ssi_addr + 1);
1402 uint16_t *tssi_addr_lsb = (uint16_t *)(&tinfo->ssi_addr + 1);
1403 *tssi_addr_lsb = tswap16(*ssi_addr_lsb);
1404 }
1405#endif
1406
1407 tinfo->ssi_signo = tswap32(sig);
1408 tinfo->ssi_errno = tswap32(tinfo->ssi_errno);
1409 tinfo->ssi_code = tswap32(info->ssi_code);
1410 tinfo->ssi_pid = tswap32(info->ssi_pid);
1411 tinfo->ssi_uid = tswap32(info->ssi_uid);
1412 tinfo->ssi_fd = tswap32(info->ssi_fd);
1413 tinfo->ssi_tid = tswap32(info->ssi_tid);
1414 tinfo->ssi_band = tswap32(info->ssi_band);
1415 tinfo->ssi_overrun = tswap32(info->ssi_overrun);
1416 tinfo->ssi_trapno = tswap32(info->ssi_trapno);
1417 tinfo->ssi_status = tswap32(info->ssi_status);
1418 tinfo->ssi_int = tswap32(info->ssi_int);
1419 tinfo->ssi_ptr = tswap64(info->ssi_ptr);
1420 tinfo->ssi_utime = tswap64(info->ssi_utime);
1421 tinfo->ssi_stime = tswap64(info->ssi_stime);
1422 tinfo->ssi_addr = tswap64(info->ssi_addr);
1423}
1424
1425static abi_long host_to_target_data_signalfd(void *buf, size_t len)
1426{
1427 int i;
1428
1429 for (i = 0; i < len; i += sizeof(struct signalfd_siginfo)) {
1430 host_to_target_signalfd_siginfo(buf + i, buf + i);
1431 }
1432
1433 return len;
1434}
1435
1436TargetFdTrans target_signalfd_trans = {
1437 .host_to_target_data = host_to_target_data_signalfd,
1438};
1439
1440static abi_long swap_data_eventfd(void *buf, size_t len)
1441{
1442 uint64_t *counter = buf;
1443 int i;
1444
1445 if (len < sizeof(uint64_t)) {
1446 return -EINVAL;
1447 }
1448
1449 for (i = 0; i < len; i += sizeof(uint64_t)) {
1450 *counter = tswap64(*counter);
1451 counter++;
1452 }
1453
1454 return len;
1455}
1456
1457TargetFdTrans target_eventfd_trans = {
1458 .host_to_target_data = swap_data_eventfd,
1459 .target_to_host_data = swap_data_eventfd,
1460};
1461
1462#if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \
1463 (defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \
1464 defined(__NR_inotify_init1))
1465static abi_long host_to_target_data_inotify(void *buf, size_t len)
1466{
1467 struct inotify_event *ev;
1468 int i;
1469 uint32_t name_len;
1470
1471 for (i = 0; i < len; i += sizeof(struct inotify_event) + name_len) {
1472 ev = (struct inotify_event *)((char *)buf + i);
1473 name_len = ev->len;
1474
1475 ev->wd = tswap32(ev->wd);
1476 ev->mask = tswap32(ev->mask);
1477 ev->cookie = tswap32(ev->cookie);
1478 ev->len = tswap32(name_len);
1479 }
1480
1481 return len;
1482}
1483
1484TargetFdTrans target_inotify_trans = {
1485 .host_to_target_data = host_to_target_data_inotify,
1486};
1487#endif
QEMU mirror