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