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