jcs.org
qemu with hax to log dma reads & writes
jcs.org/2018/11/12/vfio
linux-user: move TargetFdTrans functions to their own file
This will ease to move out syscall functions from syscall.c
Signed-off-by: Laurent Vivier <laurent@vivier.eu>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20180823222215.13781-1-laurent@vivier.eu>
+1508
-1448
+1
-1
linux-user/Makefile.objs
+1
-1
linux-user/Makefile.objs
···
1
1
obj-y = main.o syscall.o strace.o mmap.o signal.o \
2
2
elfload.o linuxload.o uaccess.o uname.o \
3
3
safe-syscall.o $(TARGET_ABI_DIR)/signal.o \
4
-
$(TARGET_ABI_DIR)/cpu_loop.o exit.o
4
+
$(TARGET_ABI_DIR)/cpu_loop.o exit.o fd-trans.o
5
5
6
6
obj-$(TARGET_HAS_BFLT) += flatload.o
7
7
obj-$(TARGET_I386) += vm86.o
+1409
linux-user/fd-trans.c
+1409
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_MAX,
79
+
};
80
+
81
+
enum {
82
+
QEMU_IFLA_UNSPEC,
83
+
QEMU_IFLA_ADDRESS,
84
+
QEMU_IFLA_BROADCAST,
85
+
QEMU_IFLA_IFNAME,
86
+
QEMU_IFLA_MTU,
87
+
QEMU_IFLA_LINK,
88
+
QEMU_IFLA_QDISC,
89
+
QEMU_IFLA_STATS,
90
+
QEMU_IFLA_COST,
91
+
QEMU_IFLA_PRIORITY,
92
+
QEMU_IFLA_MASTER,
93
+
QEMU_IFLA_WIRELESS,
94
+
QEMU_IFLA_PROTINFO,
95
+
QEMU_IFLA_TXQLEN,
96
+
QEMU_IFLA_MAP,
97
+
QEMU_IFLA_WEIGHT,
98
+
QEMU_IFLA_OPERSTATE,
99
+
QEMU_IFLA_LINKMODE,
100
+
QEMU_IFLA_LINKINFO,
101
+
QEMU_IFLA_NET_NS_PID,
102
+
QEMU_IFLA_IFALIAS,
103
+
QEMU_IFLA_NUM_VF,
104
+
QEMU_IFLA_VFINFO_LIST,
105
+
QEMU_IFLA_STATS64,
106
+
QEMU_IFLA_VF_PORTS,
107
+
QEMU_IFLA_PORT_SELF,
108
+
QEMU_IFLA_AF_SPEC,
109
+
QEMU_IFLA_GROUP,
110
+
QEMU_IFLA_NET_NS_FD,
111
+
QEMU_IFLA_EXT_MASK,
112
+
QEMU_IFLA_PROMISCUITY,
113
+
QEMU_IFLA_NUM_TX_QUEUES,
114
+
QEMU_IFLA_NUM_RX_QUEUES,
115
+
QEMU_IFLA_CARRIER,
116
+
QEMU_IFLA_PHYS_PORT_ID,
117
+
QEMU_IFLA_CARRIER_CHANGES,
118
+
QEMU_IFLA_PHYS_SWITCH_ID,
119
+
QEMU_IFLA_LINK_NETNSID,
120
+
QEMU_IFLA_PHYS_PORT_NAME,
121
+
QEMU_IFLA_PROTO_DOWN,
122
+
QEMU_IFLA_GSO_MAX_SEGS,
123
+
QEMU_IFLA_GSO_MAX_SIZE,
124
+
QEMU_IFLA_PAD,
125
+
QEMU_IFLA_XDP,
126
+
QEMU_IFLA_EVENT,
127
+
QEMU_IFLA_NEW_NETNSID,
128
+
QEMU_IFLA_IF_NETNSID,
129
+
QEMU_IFLA_CARRIER_UP_COUNT,
130
+
QEMU_IFLA_CARRIER_DOWN_COUNT,
131
+
QEMU_IFLA_NEW_IFINDEX,
132
+
QEMU___IFLA_MAX
133
+
};
134
+
135
+
enum {
136
+
QEMU_IFLA_BRPORT_UNSPEC,
137
+
QEMU_IFLA_BRPORT_STATE,
138
+
QEMU_IFLA_BRPORT_PRIORITY,
139
+
QEMU_IFLA_BRPORT_COST,
140
+
QEMU_IFLA_BRPORT_MODE,
141
+
QEMU_IFLA_BRPORT_GUARD,
142
+
QEMU_IFLA_BRPORT_PROTECT,
143
+
QEMU_IFLA_BRPORT_FAST_LEAVE,
144
+
QEMU_IFLA_BRPORT_LEARNING,
145
+
QEMU_IFLA_BRPORT_UNICAST_FLOOD,
146
+
QEMU_IFLA_BRPORT_PROXYARP,
147
+
QEMU_IFLA_BRPORT_LEARNING_SYNC,
148
+
QEMU_IFLA_BRPORT_PROXYARP_WIFI,
149
+
QEMU_IFLA_BRPORT_ROOT_ID,
150
+
QEMU_IFLA_BRPORT_BRIDGE_ID,
151
+
QEMU_IFLA_BRPORT_DESIGNATED_PORT,
152
+
QEMU_IFLA_BRPORT_DESIGNATED_COST,
153
+
QEMU_IFLA_BRPORT_ID,
154
+
QEMU_IFLA_BRPORT_NO,
155
+
QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
156
+
QEMU_IFLA_BRPORT_CONFIG_PENDING,
157
+
QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER,
158
+
QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER,
159
+
QEMU_IFLA_BRPORT_HOLD_TIMER,
160
+
QEMU_IFLA_BRPORT_FLUSH,
161
+
QEMU_IFLA_BRPORT_MULTICAST_ROUTER,
162
+
QEMU_IFLA_BRPORT_PAD,
163
+
QEMU_IFLA_BRPORT_MCAST_FLOOD,
164
+
QEMU_IFLA_BRPORT_MCAST_TO_UCAST,
165
+
QEMU_IFLA_BRPORT_VLAN_TUNNEL,
166
+
QEMU_IFLA_BRPORT_BCAST_FLOOD,
167
+
QEMU_IFLA_BRPORT_GROUP_FWD_MASK,
168
+
QEMU_IFLA_BRPORT_NEIGH_SUPPRESS,
169
+
QEMU___IFLA_BRPORT_MAX
170
+
};
171
+
172
+
enum {
173
+
QEMU_IFLA_TUN_UNSPEC,
174
+
QEMU_IFLA_TUN_OWNER,
175
+
QEMU_IFLA_TUN_GROUP,
176
+
QEMU_IFLA_TUN_TYPE,
177
+
QEMU_IFLA_TUN_PI,
178
+
QEMU_IFLA_TUN_VNET_HDR,
179
+
QEMU_IFLA_TUN_PERSIST,
180
+
QEMU_IFLA_TUN_MULTI_QUEUE,
181
+
QEMU_IFLA_TUN_NUM_QUEUES,
182
+
QEMU_IFLA_TUN_NUM_DISABLED_QUEUES,
183
+
QEMU___IFLA_TUN_MAX,
184
+
};
185
+
186
+
enum {
187
+
QEMU_IFLA_INFO_UNSPEC,
188
+
QEMU_IFLA_INFO_KIND,
189
+
QEMU_IFLA_INFO_DATA,
190
+
QEMU_IFLA_INFO_XSTATS,
191
+
QEMU_IFLA_INFO_SLAVE_KIND,
192
+
QEMU_IFLA_INFO_SLAVE_DATA,
193
+
QEMU___IFLA_INFO_MAX,
194
+
};
195
+
196
+
enum {
197
+
QEMU_IFLA_INET_UNSPEC,
198
+
QEMU_IFLA_INET_CONF,
199
+
QEMU___IFLA_INET_MAX,
200
+
};
201
+
202
+
enum {
203
+
QEMU_IFLA_INET6_UNSPEC,
204
+
QEMU_IFLA_INET6_FLAGS,
205
+
QEMU_IFLA_INET6_CONF,
206
+
QEMU_IFLA_INET6_STATS,
207
+
QEMU_IFLA_INET6_MCAST,
208
+
QEMU_IFLA_INET6_CACHEINFO,
209
+
QEMU_IFLA_INET6_ICMP6STATS,
210
+
QEMU_IFLA_INET6_TOKEN,
211
+
QEMU_IFLA_INET6_ADDR_GEN_MODE,
212
+
QEMU___IFLA_INET6_MAX
213
+
};
214
+
215
+
enum {
216
+
QEMU_IFLA_XDP_UNSPEC,
217
+
QEMU_IFLA_XDP_FD,
218
+
QEMU_IFLA_XDP_ATTACHED,
219
+
QEMU_IFLA_XDP_FLAGS,
220
+
QEMU_IFLA_XDP_PROG_ID,
221
+
QEMU___IFLA_XDP_MAX,
222
+
};
223
+
224
+
enum {
225
+
QEMU_RTA_UNSPEC,
226
+
QEMU_RTA_DST,
227
+
QEMU_RTA_SRC,
228
+
QEMU_RTA_IIF,
229
+
QEMU_RTA_OIF,
230
+
QEMU_RTA_GATEWAY,
231
+
QEMU_RTA_PRIORITY,
232
+
QEMU_RTA_PREFSRC,
233
+
QEMU_RTA_METRICS,
234
+
QEMU_RTA_MULTIPATH,
235
+
QEMU_RTA_PROTOINFO, /* no longer used */
236
+
QEMU_RTA_FLOW,
237
+
QEMU_RTA_CACHEINFO,
238
+
QEMU_RTA_SESSION, /* no longer used */
239
+
QEMU_RTA_MP_ALGO, /* no longer used */
240
+
QEMU_RTA_TABLE,
241
+
QEMU_RTA_MARK,
242
+
QEMU_RTA_MFC_STATS,
243
+
QEMU_RTA_VIA,
244
+
QEMU_RTA_NEWDST,
245
+
QEMU_RTA_PREF,
246
+
QEMU_RTA_ENCAP_TYPE,
247
+
QEMU_RTA_ENCAP,
248
+
QEMU_RTA_EXPIRES,
249
+
QEMU_RTA_PAD,
250
+
QEMU_RTA_UID,
251
+
QEMU_RTA_TTL_PROPAGATE,
252
+
QEMU_RTA_IP_PROTO,
253
+
QEMU_RTA_SPORT,
254
+
QEMU_RTA_DPORT,
255
+
QEMU___RTA_MAX
256
+
};
257
+
258
+
TargetFdTrans **target_fd_trans;
259
+
unsigned int target_fd_max;
260
+
261
+
static void tswap_nlmsghdr(struct nlmsghdr *nlh)
262
+
{
263
+
nlh->nlmsg_len = tswap32(nlh->nlmsg_len);
264
+
nlh->nlmsg_type = tswap16(nlh->nlmsg_type);
265
+
nlh->nlmsg_flags = tswap16(nlh->nlmsg_flags);
266
+
nlh->nlmsg_seq = tswap32(nlh->nlmsg_seq);
267
+
nlh->nlmsg_pid = tswap32(nlh->nlmsg_pid);
268
+
}
269
+
270
+
static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
271
+
size_t len,
272
+
abi_long (*host_to_target_nlmsg)
273
+
(struct nlmsghdr *))
274
+
{
275
+
uint32_t nlmsg_len;
276
+
abi_long ret;
277
+
278
+
while (len > sizeof(struct nlmsghdr)) {
279
+
280
+
nlmsg_len = nlh->nlmsg_len;
281
+
if (nlmsg_len < sizeof(struct nlmsghdr) ||
282
+
nlmsg_len > len) {
283
+
break;
284
+
}
285
+
286
+
switch (nlh->nlmsg_type) {
287
+
case NLMSG_DONE:
288
+
tswap_nlmsghdr(nlh);
289
+
return 0;
290
+
case NLMSG_NOOP:
291
+
break;
292
+
case NLMSG_ERROR:
293
+
{
294
+
struct nlmsgerr *e = NLMSG_DATA(nlh);
295
+
e->error = tswap32(e->error);
296
+
tswap_nlmsghdr(&e->msg);
297
+
tswap_nlmsghdr(nlh);
298
+
return 0;
299
+
}
300
+
default:
301
+
ret = host_to_target_nlmsg(nlh);
302
+
if (ret < 0) {
303
+
tswap_nlmsghdr(nlh);
304
+
return ret;
305
+
}
306
+
break;
307
+
}
308
+
tswap_nlmsghdr(nlh);
309
+
len -= NLMSG_ALIGN(nlmsg_len);
310
+
nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len));
311
+
}
312
+
return 0;
313
+
}
314
+
315
+
static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
316
+
size_t len,
317
+
abi_long (*target_to_host_nlmsg)
318
+
(struct nlmsghdr *))
319
+
{
320
+
int ret;
321
+
322
+
while (len > sizeof(struct nlmsghdr)) {
323
+
if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) ||
324
+
tswap32(nlh->nlmsg_len) > len) {
325
+
break;
326
+
}
327
+
tswap_nlmsghdr(nlh);
328
+
switch (nlh->nlmsg_type) {
329
+
case NLMSG_DONE:
330
+
return 0;
331
+
case NLMSG_NOOP:
332
+
break;
333
+
case NLMSG_ERROR:
334
+
{
335
+
struct nlmsgerr *e = NLMSG_DATA(nlh);
336
+
e->error = tswap32(e->error);
337
+
tswap_nlmsghdr(&e->msg);
338
+
return 0;
339
+
}
340
+
default:
341
+
ret = target_to_host_nlmsg(nlh);
342
+
if (ret < 0) {
343
+
return ret;
344
+
}
345
+
}
346
+
len -= NLMSG_ALIGN(nlh->nlmsg_len);
347
+
nlh = (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg_len));
348
+
}
349
+
return 0;
350
+
}
351
+
352
+
#ifdef CONFIG_RTNETLINK
353
+
static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
354
+
size_t len, void *context,
355
+
abi_long (*host_to_target_nlattr)
356
+
(struct nlattr *,
357
+
void *context))
358
+
{
359
+
unsigned short nla_len;
360
+
abi_long ret;
361
+
362
+
while (len > sizeof(struct nlattr)) {
363
+
nla_len = nlattr->nla_len;
364
+
if (nla_len < sizeof(struct nlattr) ||
365
+
nla_len > len) {
366
+
break;
367
+
}
368
+
ret = host_to_target_nlattr(nlattr, context);
369
+
nlattr->nla_len = tswap16(nlattr->nla_len);
370
+
nlattr->nla_type = tswap16(nlattr->nla_type);
371
+
if (ret < 0) {
372
+
return ret;
373
+
}
374
+
len -= NLA_ALIGN(nla_len);
375
+
nlattr = (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len));
376
+
}
377
+
return 0;
378
+
}
379
+
380
+
static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
381
+
size_t len,
382
+
abi_long (*host_to_target_rtattr)
383
+
(struct rtattr *))
384
+
{
385
+
unsigned short rta_len;
386
+
abi_long ret;
387
+
388
+
while (len > sizeof(struct rtattr)) {
389
+
rta_len = rtattr->rta_len;
390
+
if (rta_len < sizeof(struct rtattr) ||
391
+
rta_len > len) {
392
+
break;
393
+
}
394
+
ret = host_to_target_rtattr(rtattr);
395
+
rtattr->rta_len = tswap16(rtattr->rta_len);
396
+
rtattr->rta_type = tswap16(rtattr->rta_type);
397
+
if (ret < 0) {
398
+
return ret;
399
+
}
400
+
len -= RTA_ALIGN(rta_len);
401
+
rtattr = (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len));
402
+
}
403
+
return 0;
404
+
}
405
+
406
+
#define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN)
407
+
408
+
static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr,
409
+
void *context)
410
+
{
411
+
uint16_t *u16;
412
+
uint32_t *u32;
413
+
uint64_t *u64;
414
+
415
+
switch (nlattr->nla_type) {
416
+
/* no data */
417
+
case QEMU_IFLA_BR_FDB_FLUSH:
418
+
break;
419
+
/* binary */
420
+
case QEMU_IFLA_BR_GROUP_ADDR:
421
+
break;
422
+
/* uint8_t */
423
+
case QEMU_IFLA_BR_VLAN_FILTERING:
424
+
case QEMU_IFLA_BR_TOPOLOGY_CHANGE:
425
+
case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED:
426
+
case QEMU_IFLA_BR_MCAST_ROUTER:
427
+
case QEMU_IFLA_BR_MCAST_SNOOPING:
428
+
case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR:
429
+
case QEMU_IFLA_BR_MCAST_QUERIER:
430
+
case QEMU_IFLA_BR_NF_CALL_IPTABLES:
431
+
case QEMU_IFLA_BR_NF_CALL_IP6TABLES:
432
+
case QEMU_IFLA_BR_NF_CALL_ARPTABLES:
433
+
case QEMU_IFLA_BR_VLAN_STATS_ENABLED:
434
+
case QEMU_IFLA_BR_MCAST_STATS_ENABLED:
435
+
case QEMU_IFLA_BR_MCAST_IGMP_VERSION:
436
+
case QEMU_IFLA_BR_MCAST_MLD_VERSION:
437
+
break;
438
+
/* uint16_t */
439
+
case QEMU_IFLA_BR_PRIORITY:
440
+
case QEMU_IFLA_BR_VLAN_PROTOCOL:
441
+
case QEMU_IFLA_BR_GROUP_FWD_MASK:
442
+
case QEMU_IFLA_BR_ROOT_PORT:
443
+
case QEMU_IFLA_BR_VLAN_DEFAULT_PVID:
444
+
u16 = NLA_DATA(nlattr);
445
+
*u16 = tswap16(*u16);
446
+
break;
447
+
/* uint32_t */
448
+
case QEMU_IFLA_BR_FORWARD_DELAY:
449
+
case QEMU_IFLA_BR_HELLO_TIME:
450
+
case QEMU_IFLA_BR_MAX_AGE:
451
+
case QEMU_IFLA_BR_AGEING_TIME:
452
+
case QEMU_IFLA_BR_STP_STATE:
453
+
case QEMU_IFLA_BR_ROOT_PATH_COST:
454
+
case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY:
455
+
case QEMU_IFLA_BR_MCAST_HASH_MAX:
456
+
case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT:
457
+
case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT:
458
+
u32 = NLA_DATA(nlattr);
459
+
*u32 = tswap32(*u32);
460
+
break;
461
+
/* uint64_t */
462
+
case QEMU_IFLA_BR_HELLO_TIMER:
463
+
case QEMU_IFLA_BR_TCN_TIMER:
464
+
case QEMU_IFLA_BR_GC_TIMER:
465
+
case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER:
466
+
case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL:
467
+
case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL:
468
+
case QEMU_IFLA_BR_MCAST_QUERIER_INTVL:
469
+
case QEMU_IFLA_BR_MCAST_QUERY_INTVL:
470
+
case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL:
471
+
case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL:
472
+
u64 = NLA_DATA(nlattr);
473
+
*u64 = tswap64(*u64);
474
+
break;
475
+
/* ifla_bridge_id: uin8_t[] */
476
+
case QEMU_IFLA_BR_ROOT_ID:
477
+
case QEMU_IFLA_BR_BRIDGE_ID:
478
+
break;
479
+
default:
480
+
gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr->nla_type);
481
+
break;
482
+
}
483
+
return 0;
484
+
}
485
+
486
+
static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nlattr,
487
+
void *context)
488
+
{
489
+
uint16_t *u16;
490
+
uint32_t *u32;
491
+
uint64_t *u64;
492
+
493
+
switch (nlattr->nla_type) {
494
+
/* uint8_t */
495
+
case QEMU_IFLA_BRPORT_STATE:
496
+
case QEMU_IFLA_BRPORT_MODE:
497
+
case QEMU_IFLA_BRPORT_GUARD:
498
+
case QEMU_IFLA_BRPORT_PROTECT:
499
+
case QEMU_IFLA_BRPORT_FAST_LEAVE:
500
+
case QEMU_IFLA_BRPORT_LEARNING:
501
+
case QEMU_IFLA_BRPORT_UNICAST_FLOOD:
502
+
case QEMU_IFLA_BRPORT_PROXYARP:
503
+
case QEMU_IFLA_BRPORT_LEARNING_SYNC:
504
+
case QEMU_IFLA_BRPORT_PROXYARP_WIFI:
505
+
case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK:
506
+
case QEMU_IFLA_BRPORT_CONFIG_PENDING:
507
+
case QEMU_IFLA_BRPORT_MULTICAST_ROUTER:
508
+
case QEMU_IFLA_BRPORT_MCAST_FLOOD:
509
+
case QEMU_IFLA_BRPORT_MCAST_TO_UCAST:
510
+
case QEMU_IFLA_BRPORT_VLAN_TUNNEL:
511
+
case QEMU_IFLA_BRPORT_BCAST_FLOOD:
512
+
case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS:
513
+
break;
514
+
/* uint16_t */
515
+
case QEMU_IFLA_BRPORT_PRIORITY:
516
+
case QEMU_IFLA_BRPORT_DESIGNATED_PORT:
517
+
case QEMU_IFLA_BRPORT_DESIGNATED_COST:
518
+
case QEMU_IFLA_BRPORT_ID:
519
+
case QEMU_IFLA_BRPORT_NO:
520
+
case QEMU_IFLA_BRPORT_GROUP_FWD_MASK:
521
+
u16 = NLA_DATA(nlattr);
522
+
*u16 = tswap16(*u16);
523
+
break;
524
+
/* uin32_t */
525
+
case QEMU_IFLA_BRPORT_COST:
526
+
u32 = NLA_DATA(nlattr);
527
+
*u32 = tswap32(*u32);
528
+
break;
529
+
/* uint64_t */
530
+
case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER:
531
+
case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER:
532
+
case QEMU_IFLA_BRPORT_HOLD_TIMER:
533
+
u64 = NLA_DATA(nlattr);
534
+
*u64 = tswap64(*u64);
535
+
break;
536
+
/* ifla_bridge_id: uint8_t[] */
537
+
case QEMU_IFLA_BRPORT_ROOT_ID:
538
+
case QEMU_IFLA_BRPORT_BRIDGE_ID:
539
+
break;
540
+
default:
541
+
gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr->nla_type);
542
+
break;
543
+
}
544
+
return 0;
545
+
}
546
+
547
+
static abi_long host_to_target_data_tun_nlattr(struct nlattr *nlattr,
548
+
void *context)
549
+
{
550
+
uint32_t *u32;
551
+
552
+
switch (nlattr->nla_type) {
553
+
/* uint8_t */
554
+
case QEMU_IFLA_TUN_TYPE:
555
+
case QEMU_IFLA_TUN_PI:
556
+
case QEMU_IFLA_TUN_VNET_HDR:
557
+
case QEMU_IFLA_TUN_PERSIST:
558
+
case QEMU_IFLA_TUN_MULTI_QUEUE:
559
+
break;
560
+
/* uint32_t */
561
+
case QEMU_IFLA_TUN_NUM_QUEUES:
562
+
case QEMU_IFLA_TUN_NUM_DISABLED_QUEUES:
563
+
case QEMU_IFLA_TUN_OWNER:
564
+
case QEMU_IFLA_TUN_GROUP:
565
+
u32 = NLA_DATA(nlattr);
566
+
*u32 = tswap32(*u32);
567
+
break;
568
+
default:
569
+
gemu_log("Unknown QEMU_IFLA_TUN type %d\n", nlattr->nla_type);
570
+
break;
571
+
}
572
+
return 0;
573
+
}
574
+
575
+
struct linkinfo_context {
576
+
int len;
577
+
char *name;
578
+
int slave_len;
579
+
char *slave_name;
580
+
};
581
+
582
+
static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr,
583
+
void *context)
584
+
{
585
+
struct linkinfo_context *li_context = context;
586
+
587
+
switch (nlattr->nla_type) {
588
+
/* string */
589
+
case QEMU_IFLA_INFO_KIND:
590
+
li_context->name = NLA_DATA(nlattr);
591
+
li_context->len = nlattr->nla_len - NLA_HDRLEN;
592
+
break;
593
+
case QEMU_IFLA_INFO_SLAVE_KIND:
594
+
li_context->slave_name = NLA_DATA(nlattr);
595
+
li_context->slave_len = nlattr->nla_len - NLA_HDRLEN;
596
+
break;
597
+
/* stats */
598
+
case QEMU_IFLA_INFO_XSTATS:
599
+
/* FIXME: only used by CAN */
600
+
break;
601
+
/* nested */
602
+
case QEMU_IFLA_INFO_DATA:
603
+
if (strncmp(li_context->name, "bridge",
604
+
li_context->len) == 0) {
605
+
return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
606
+
nlattr->nla_len,
607
+
NULL,
608
+
host_to_target_data_bridge_nlattr);
609
+
} else if (strncmp(li_context->name, "tun",
610
+
li_context->len) == 0) {
611
+
return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
612
+
nlattr->nla_len,
613
+
NULL,
614
+
host_to_target_data_tun_nlattr);
615
+
} else {
616
+
gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context->name);
617
+
}
618
+
break;
619
+
case QEMU_IFLA_INFO_SLAVE_DATA:
620
+
if (strncmp(li_context->slave_name, "bridge",
621
+
li_context->slave_len) == 0) {
622
+
return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
623
+
nlattr->nla_len,
624
+
NULL,
625
+
host_to_target_slave_data_bridge_nlattr);
626
+
} else {
627
+
gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n",
628
+
li_context->slave_name);
629
+
}
630
+
break;
631
+
default:
632
+
gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr->nla_type);
633
+
break;
634
+
}
635
+
636
+
return 0;
637
+
}
638
+
639
+
static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr,
640
+
void *context)
641
+
{
642
+
uint32_t *u32;
643
+
int i;
644
+
645
+
switch (nlattr->nla_type) {
646
+
case QEMU_IFLA_INET_CONF:
647
+
u32 = NLA_DATA(nlattr);
648
+
for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
649
+
i++) {
650
+
u32[i] = tswap32(u32[i]);
651
+
}
652
+
break;
653
+
default:
654
+
gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type);
655
+
}
656
+
return 0;
657
+
}
658
+
659
+
static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr,
660
+
void *context)
661
+
{
662
+
uint32_t *u32;
663
+
uint64_t *u64;
664
+
struct ifla_cacheinfo *ci;
665
+
int i;
666
+
667
+
switch (nlattr->nla_type) {
668
+
/* binaries */
669
+
case QEMU_IFLA_INET6_TOKEN:
670
+
break;
671
+
/* uint8_t */
672
+
case QEMU_IFLA_INET6_ADDR_GEN_MODE:
673
+
break;
674
+
/* uint32_t */
675
+
case QEMU_IFLA_INET6_FLAGS:
676
+
u32 = NLA_DATA(nlattr);
677
+
*u32 = tswap32(*u32);
678
+
break;
679
+
/* uint32_t[] */
680
+
case QEMU_IFLA_INET6_CONF:
681
+
u32 = NLA_DATA(nlattr);
682
+
for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
683
+
i++) {
684
+
u32[i] = tswap32(u32[i]);
685
+
}
686
+
break;
687
+
/* ifla_cacheinfo */
688
+
case QEMU_IFLA_INET6_CACHEINFO:
689
+
ci = NLA_DATA(nlattr);
690
+
ci->max_reasm_len = tswap32(ci->max_reasm_len);
691
+
ci->tstamp = tswap32(ci->tstamp);
692
+
ci->reachable_time = tswap32(ci->reachable_time);
693
+
ci->retrans_time = tswap32(ci->retrans_time);
694
+
break;
695
+
/* uint64_t[] */
696
+
case QEMU_IFLA_INET6_STATS:
697
+
case QEMU_IFLA_INET6_ICMP6STATS:
698
+
u64 = NLA_DATA(nlattr);
699
+
for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64);
700
+
i++) {
701
+
u64[i] = tswap64(u64[i]);
702
+
}
703
+
break;
704
+
default:
705
+
gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type);
706
+
}
707
+
return 0;
708
+
}
709
+
710
+
static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr,
711
+
void *context)
712
+
{
713
+
switch (nlattr->nla_type) {
714
+
case AF_INET:
715
+
return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
716
+
NULL,
717
+
host_to_target_data_inet_nlattr);
718
+
case AF_INET6:
719
+
return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
720
+
NULL,
721
+
host_to_target_data_inet6_nlattr);
722
+
default:
723
+
gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type);
724
+
break;
725
+
}
726
+
return 0;
727
+
}
728
+
729
+
static abi_long host_to_target_data_xdp_nlattr(struct nlattr *nlattr,
730
+
void *context)
731
+
{
732
+
uint32_t *u32;
733
+
734
+
switch (nlattr->nla_type) {
735
+
/* uint8_t */
736
+
case QEMU_IFLA_XDP_ATTACHED:
737
+
break;
738
+
/* uint32_t */
739
+
case QEMU_IFLA_XDP_PROG_ID:
740
+
u32 = NLA_DATA(nlattr);
741
+
*u32 = tswap32(*u32);
742
+
break;
743
+
default:
744
+
gemu_log("Unknown host XDP type: %d\n", nlattr->nla_type);
745
+
break;
746
+
}
747
+
return 0;
748
+
}
749
+
750
+
static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr)
751
+
{
752
+
uint32_t *u32;
753
+
struct rtnl_link_stats *st;
754
+
struct rtnl_link_stats64 *st64;
755
+
struct rtnl_link_ifmap *map;
756
+
struct linkinfo_context li_context;
757
+
758
+
switch (rtattr->rta_type) {
759
+
/* binary stream */
760
+
case QEMU_IFLA_ADDRESS:
761
+
case QEMU_IFLA_BROADCAST:
762
+
/* string */
763
+
case QEMU_IFLA_IFNAME:
764
+
case QEMU_IFLA_QDISC:
765
+
break;
766
+
/* uin8_t */
767
+
case QEMU_IFLA_OPERSTATE:
768
+
case QEMU_IFLA_LINKMODE:
769
+
case QEMU_IFLA_CARRIER:
770
+
case QEMU_IFLA_PROTO_DOWN:
771
+
break;
772
+
/* uint32_t */
773
+
case QEMU_IFLA_MTU:
774
+
case QEMU_IFLA_LINK:
775
+
case QEMU_IFLA_WEIGHT:
776
+
case QEMU_IFLA_TXQLEN:
777
+
case QEMU_IFLA_CARRIER_CHANGES:
778
+
case QEMU_IFLA_NUM_RX_QUEUES:
779
+
case QEMU_IFLA_NUM_TX_QUEUES:
780
+
case QEMU_IFLA_PROMISCUITY:
781
+
case QEMU_IFLA_EXT_MASK:
782
+
case QEMU_IFLA_LINK_NETNSID:
783
+
case QEMU_IFLA_GROUP:
784
+
case QEMU_IFLA_MASTER:
785
+
case QEMU_IFLA_NUM_VF:
786
+
case QEMU_IFLA_GSO_MAX_SEGS:
787
+
case QEMU_IFLA_GSO_MAX_SIZE:
788
+
case QEMU_IFLA_CARRIER_UP_COUNT:
789
+
case QEMU_IFLA_CARRIER_DOWN_COUNT:
790
+
u32 = RTA_DATA(rtattr);
791
+
*u32 = tswap32(*u32);
792
+
break;
793
+
/* struct rtnl_link_stats */
794
+
case QEMU_IFLA_STATS:
795
+
st = RTA_DATA(rtattr);
796
+
st->rx_packets = tswap32(st->rx_packets);
797
+
st->tx_packets = tswap32(st->tx_packets);
798
+
st->rx_bytes = tswap32(st->rx_bytes);
799
+
st->tx_bytes = tswap32(st->tx_bytes);
800
+
st->rx_errors = tswap32(st->rx_errors);
801
+
st->tx_errors = tswap32(st->tx_errors);
802
+
st->rx_dropped = tswap32(st->rx_dropped);
803
+
st->tx_dropped = tswap32(st->tx_dropped);
804
+
st->multicast = tswap32(st->multicast);
805
+
st->collisions = tswap32(st->collisions);
806
+
807
+
/* detailed rx_errors: */
808
+
st->rx_length_errors = tswap32(st->rx_length_errors);
809
+
st->rx_over_errors = tswap32(st->rx_over_errors);
810
+
st->rx_crc_errors = tswap32(st->rx_crc_errors);
811
+
st->rx_frame_errors = tswap32(st->rx_frame_errors);
812
+
st->rx_fifo_errors = tswap32(st->rx_fifo_errors);
813
+
st->rx_missed_errors = tswap32(st->rx_missed_errors);
814
+
815
+
/* detailed tx_errors */
816
+
st->tx_aborted_errors = tswap32(st->tx_aborted_errors);
817
+
st->tx_carrier_errors = tswap32(st->tx_carrier_errors);
818
+
st->tx_fifo_errors = tswap32(st->tx_fifo_errors);
819
+
st->tx_heartbeat_errors = tswap32(st->tx_heartbeat_errors);
820
+
st->tx_window_errors = tswap32(st->tx_window_errors);
821
+
822
+
/* for cslip etc */
823
+
st->rx_compressed = tswap32(st->rx_compressed);
824
+
st->tx_compressed = tswap32(st->tx_compressed);
825
+
break;
826
+
/* struct rtnl_link_stats64 */
827
+
case QEMU_IFLA_STATS64:
828
+
st64 = RTA_DATA(rtattr);
829
+
st64->rx_packets = tswap64(st64->rx_packets);
830
+
st64->tx_packets = tswap64(st64->tx_packets);
831
+
st64->rx_bytes = tswap64(st64->rx_bytes);
832
+
st64->tx_bytes = tswap64(st64->tx_bytes);
833
+
st64->rx_errors = tswap64(st64->rx_errors);
834
+
st64->tx_errors = tswap64(st64->tx_errors);
835
+
st64->rx_dropped = tswap64(st64->rx_dropped);
836
+
st64->tx_dropped = tswap64(st64->tx_dropped);
837
+
st64->multicast = tswap64(st64->multicast);
838
+
st64->collisions = tswap64(st64->collisions);
839
+
840
+
/* detailed rx_errors: */
841
+
st64->rx_length_errors = tswap64(st64->rx_length_errors);
842
+
st64->rx_over_errors = tswap64(st64->rx_over_errors);
843
+
st64->rx_crc_errors = tswap64(st64->rx_crc_errors);
844
+
st64->rx_frame_errors = tswap64(st64->rx_frame_errors);
845
+
st64->rx_fifo_errors = tswap64(st64->rx_fifo_errors);
846
+
st64->rx_missed_errors = tswap64(st64->rx_missed_errors);
847
+
848
+
/* detailed tx_errors */
849
+
st64->tx_aborted_errors = tswap64(st64->tx_aborted_errors);
850
+
st64->tx_carrier_errors = tswap64(st64->tx_carrier_errors);
851
+
st64->tx_fifo_errors = tswap64(st64->tx_fifo_errors);
852
+
st64->tx_heartbeat_errors = tswap64(st64->tx_heartbeat_errors);
853
+
st64->tx_window_errors = tswap64(st64->tx_window_errors);
854
+
855
+
/* for cslip etc */
856
+
st64->rx_compressed = tswap64(st64->rx_compressed);
857
+
st64->tx_compressed = tswap64(st64->tx_compressed);
858
+
break;
859
+
/* struct rtnl_link_ifmap */
860
+
case QEMU_IFLA_MAP:
861
+
map = RTA_DATA(rtattr);
862
+
map->mem_start = tswap64(map->mem_start);
863
+
map->mem_end = tswap64(map->mem_end);
864
+
map->base_addr = tswap64(map->base_addr);
865
+
map->irq = tswap16(map->irq);
866
+
break;
867
+
/* nested */
868
+
case QEMU_IFLA_LINKINFO:
869
+
memset(&li_context, 0, sizeof(li_context));
870
+
return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
871
+
&li_context,
872
+
host_to_target_data_linkinfo_nlattr);
873
+
case QEMU_IFLA_AF_SPEC:
874
+
return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
875
+
NULL,
876
+
host_to_target_data_spec_nlattr);
877
+
case QEMU_IFLA_XDP:
878
+
return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
879
+
NULL,
880
+
host_to_target_data_xdp_nlattr);
881
+
default:
882
+
gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr->rta_type);
883
+
break;
884
+
}
885
+
return 0;
886
+
}
887
+
888
+
static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr)
889
+
{
890
+
uint32_t *u32;
891
+
struct ifa_cacheinfo *ci;
892
+
893
+
switch (rtattr->rta_type) {
894
+
/* binary: depends on family type */
895
+
case IFA_ADDRESS:
896
+
case IFA_LOCAL:
897
+
break;
898
+
/* string */
899
+
case IFA_LABEL:
900
+
break;
901
+
/* u32 */
902
+
case IFA_FLAGS:
903
+
case IFA_BROADCAST:
904
+
u32 = RTA_DATA(rtattr);
905
+
*u32 = tswap32(*u32);
906
+
break;
907
+
/* struct ifa_cacheinfo */
908
+
case IFA_CACHEINFO:
909
+
ci = RTA_DATA(rtattr);
910
+
ci->ifa_prefered = tswap32(ci->ifa_prefered);
911
+
ci->ifa_valid = tswap32(ci->ifa_valid);
912
+
ci->cstamp = tswap32(ci->cstamp);
913
+
ci->tstamp = tswap32(ci->tstamp);
914
+
break;
915
+
default:
916
+
gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type);
917
+
break;
918
+
}
919
+
return 0;
920
+
}
921
+
922
+
static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr)
923
+
{
924
+
uint32_t *u32;
925
+
struct rta_cacheinfo *ci;
926
+
927
+
switch (rtattr->rta_type) {
928
+
/* binary: depends on family type */
929
+
case QEMU_RTA_GATEWAY:
930
+
case QEMU_RTA_DST:
931
+
case QEMU_RTA_PREFSRC:
932
+
break;
933
+
/* u8 */
934
+
case QEMU_RTA_PREF:
935
+
break;
936
+
/* u32 */
937
+
case QEMU_RTA_PRIORITY:
938
+
case QEMU_RTA_TABLE:
939
+
case QEMU_RTA_OIF:
940
+
u32 = RTA_DATA(rtattr);
941
+
*u32 = tswap32(*u32);
942
+
break;
943
+
/* struct rta_cacheinfo */
944
+
case QEMU_RTA_CACHEINFO:
945
+
ci = RTA_DATA(rtattr);
946
+
ci->rta_clntref = tswap32(ci->rta_clntref);
947
+
ci->rta_lastuse = tswap32(ci->rta_lastuse);
948
+
ci->rta_expires = tswap32(ci->rta_expires);
949
+
ci->rta_error = tswap32(ci->rta_error);
950
+
ci->rta_used = tswap32(ci->rta_used);
951
+
#if defined(RTNETLINK_HAVE_PEERINFO)
952
+
ci->rta_id = tswap32(ci->rta_id);
953
+
ci->rta_ts = tswap32(ci->rta_ts);
954
+
ci->rta_tsage = tswap32(ci->rta_tsage);
955
+
#endif
956
+
break;
957
+
default:
958
+
gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type);
959
+
break;
960
+
}
961
+
return 0;
962
+
}
963
+
964
+
static abi_long host_to_target_link_rtattr(struct rtattr *rtattr,
965
+
uint32_t rtattr_len)
966
+
{
967
+
return host_to_target_for_each_rtattr(rtattr, rtattr_len,
968
+
host_to_target_data_link_rtattr);
969
+
}
970
+
971
+
static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr,
972
+
uint32_t rtattr_len)
973
+
{
974
+
return host_to_target_for_each_rtattr(rtattr, rtattr_len,
975
+
host_to_target_data_addr_rtattr);
976
+
}
977
+
978
+
static abi_long host_to_target_route_rtattr(struct rtattr *rtattr,
979
+
uint32_t rtattr_len)
980
+
{
981
+
return host_to_target_for_each_rtattr(rtattr, rtattr_len,
982
+
host_to_target_data_route_rtattr);
983
+
}
984
+
985
+
static abi_long host_to_target_data_route(struct nlmsghdr *nlh)
986
+
{
987
+
uint32_t nlmsg_len;
988
+
struct ifinfomsg *ifi;
989
+
struct ifaddrmsg *ifa;
990
+
struct rtmsg *rtm;
991
+
992
+
nlmsg_len = nlh->nlmsg_len;
993
+
switch (nlh->nlmsg_type) {
994
+
case RTM_NEWLINK:
995
+
case RTM_DELLINK:
996
+
case RTM_GETLINK:
997
+
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
998
+
ifi = NLMSG_DATA(nlh);
999
+
ifi->ifi_type = tswap16(ifi->ifi_type);
1000
+
ifi->ifi_index = tswap32(ifi->ifi_index);
1001
+
ifi->ifi_flags = tswap32(ifi->ifi_flags);
1002
+
ifi->ifi_change = tswap32(ifi->ifi_change);
1003
+
host_to_target_link_rtattr(IFLA_RTA(ifi),
1004
+
nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));
1005
+
}
1006
+
break;
1007
+
case RTM_NEWADDR:
1008
+
case RTM_DELADDR:
1009
+
case RTM_GETADDR:
1010
+
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
1011
+
ifa = NLMSG_DATA(nlh);
1012
+
ifa->ifa_index = tswap32(ifa->ifa_index);
1013
+
host_to_target_addr_rtattr(IFA_RTA(ifa),
1014
+
nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
1015
+
}
1016
+
break;
1017
+
case RTM_NEWROUTE:
1018
+
case RTM_DELROUTE:
1019
+
case RTM_GETROUTE:
1020
+
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
1021
+
rtm = NLMSG_DATA(nlh);
1022
+
rtm->rtm_flags = tswap32(rtm->rtm_flags);
1023
+
host_to_target_route_rtattr(RTM_RTA(rtm),
1024
+
nlmsg_len - NLMSG_LENGTH(sizeof(*rtm)));
1025
+
}
1026
+
break;
1027
+
default:
1028
+
return -TARGET_EINVAL;
1029
+
}
1030
+
return 0;
1031
+
}
1032
+
1033
+
static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh,
1034
+
size_t len)
1035
+
{
1036
+
return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_route);
1037
+
}
1038
+
1039
+
static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
1040
+
size_t len,
1041
+
abi_long (*target_to_host_rtattr)
1042
+
(struct rtattr *))
1043
+
{
1044
+
abi_long ret;
1045
+
1046
+
while (len >= sizeof(struct rtattr)) {
1047
+
if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) ||
1048
+
tswap16(rtattr->rta_len) > len) {
1049
+
break;
1050
+
}
1051
+
rtattr->rta_len = tswap16(rtattr->rta_len);
1052
+
rtattr->rta_type = tswap16(rtattr->rta_type);
1053
+
ret = target_to_host_rtattr(rtattr);
1054
+
if (ret < 0) {
1055
+
return ret;
1056
+
}
1057
+
len -= RTA_ALIGN(rtattr->rta_len);
1058
+
rtattr = (struct rtattr *)(((char *)rtattr) +
1059
+
RTA_ALIGN(rtattr->rta_len));
1060
+
}
1061
+
return 0;
1062
+
}
1063
+
1064
+
static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr)
1065
+
{
1066
+
switch (rtattr->rta_type) {
1067
+
default:
1068
+
gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr->rta_type);
1069
+
break;
1070
+
}
1071
+
return 0;
1072
+
}
1073
+
1074
+
static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr)
1075
+
{
1076
+
switch (rtattr->rta_type) {
1077
+
/* binary: depends on family type */
1078
+
case IFA_LOCAL:
1079
+
case IFA_ADDRESS:
1080
+
break;
1081
+
default:
1082
+
gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type);
1083
+
break;
1084
+
}
1085
+
return 0;
1086
+
}
1087
+
1088
+
static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr)
1089
+
{
1090
+
uint32_t *u32;
1091
+
switch (rtattr->rta_type) {
1092
+
/* binary: depends on family type */
1093
+
case QEMU_RTA_DST:
1094
+
case QEMU_RTA_SRC:
1095
+
case QEMU_RTA_GATEWAY:
1096
+
break;
1097
+
/* u32 */
1098
+
case QEMU_RTA_PRIORITY:
1099
+
case QEMU_RTA_OIF:
1100
+
u32 = RTA_DATA(rtattr);
1101
+
*u32 = tswap32(*u32);
1102
+
break;
1103
+
default:
1104
+
gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type);
1105
+
break;
1106
+
}
1107
+
return 0;
1108
+
}
1109
+
1110
+
static void target_to_host_link_rtattr(struct rtattr *rtattr,
1111
+
uint32_t rtattr_len)
1112
+
{
1113
+
target_to_host_for_each_rtattr(rtattr, rtattr_len,
1114
+
target_to_host_data_link_rtattr);
1115
+
}
1116
+
1117
+
static void target_to_host_addr_rtattr(struct rtattr *rtattr,
1118
+
uint32_t rtattr_len)
1119
+
{
1120
+
target_to_host_for_each_rtattr(rtattr, rtattr_len,
1121
+
target_to_host_data_addr_rtattr);
1122
+
}
1123
+
1124
+
static void target_to_host_route_rtattr(struct rtattr *rtattr,
1125
+
uint32_t rtattr_len)
1126
+
{
1127
+
target_to_host_for_each_rtattr(rtattr, rtattr_len,
1128
+
target_to_host_data_route_rtattr);
1129
+
}
1130
+
1131
+
static abi_long target_to_host_data_route(struct nlmsghdr *nlh)
1132
+
{
1133
+
struct ifinfomsg *ifi;
1134
+
struct ifaddrmsg *ifa;
1135
+
struct rtmsg *rtm;
1136
+
1137
+
switch (nlh->nlmsg_type) {
1138
+
case RTM_GETLINK:
1139
+
break;
1140
+
case RTM_NEWLINK:
1141
+
case RTM_DELLINK:
1142
+
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
1143
+
ifi = NLMSG_DATA(nlh);
1144
+
ifi->ifi_type = tswap16(ifi->ifi_type);
1145
+
ifi->ifi_index = tswap32(ifi->ifi_index);
1146
+
ifi->ifi_flags = tswap32(ifi->ifi_flags);
1147
+
ifi->ifi_change = tswap32(ifi->ifi_change);
1148
+
target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len -
1149
+
NLMSG_LENGTH(sizeof(*ifi)));
1150
+
}
1151
+
break;
1152
+
case RTM_GETADDR:
1153
+
case RTM_NEWADDR:
1154
+
case RTM_DELADDR:
1155
+
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
1156
+
ifa = NLMSG_DATA(nlh);
1157
+
ifa->ifa_index = tswap32(ifa->ifa_index);
1158
+
target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len -
1159
+
NLMSG_LENGTH(sizeof(*ifa)));
1160
+
}
1161
+
break;
1162
+
case RTM_GETROUTE:
1163
+
break;
1164
+
case RTM_NEWROUTE:
1165
+
case RTM_DELROUTE:
1166
+
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
1167
+
rtm = NLMSG_DATA(nlh);
1168
+
rtm->rtm_flags = tswap32(rtm->rtm_flags);
1169
+
target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len -
1170
+
NLMSG_LENGTH(sizeof(*rtm)));
1171
+
}
1172
+
break;
1173
+
default:
1174
+
return -TARGET_EOPNOTSUPP;
1175
+
}
1176
+
return 0;
1177
+
}
1178
+
1179
+
static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t len)
1180
+
{
1181
+
return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_route);
1182
+
}
1183
+
#endif /* CONFIG_RTNETLINK */
1184
+
1185
+
static abi_long host_to_target_data_audit(struct nlmsghdr *nlh)
1186
+
{
1187
+
switch (nlh->nlmsg_type) {
1188
+
default:
1189
+
gemu_log("Unknown host audit message type %d\n",
1190
+
nlh->nlmsg_type);
1191
+
return -TARGET_EINVAL;
1192
+
}
1193
+
return 0;
1194
+
}
1195
+
1196
+
static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh,
1197
+
size_t len)
1198
+
{
1199
+
return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_audit);
1200
+
}
1201
+
1202
+
static abi_long target_to_host_data_audit(struct nlmsghdr *nlh)
1203
+
{
1204
+
switch (nlh->nlmsg_type) {
1205
+
case AUDIT_USER:
1206
+
case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG:
1207
+
case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2:
1208
+
break;
1209
+
default:
1210
+
gemu_log("Unknown target audit message type %d\n",
1211
+
nlh->nlmsg_type);
1212
+
return -TARGET_EINVAL;
1213
+
}
1214
+
1215
+
return 0;
1216
+
}
1217
+
1218
+
static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t len)
1219
+
{
1220
+
return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_audit);
1221
+
}
1222
+
1223
+
static abi_long packet_target_to_host_sockaddr(void *host_addr,
1224
+
abi_ulong target_addr,
1225
+
socklen_t len)
1226
+
{
1227
+
struct sockaddr *addr = host_addr;
1228
+
struct target_sockaddr *target_saddr;
1229
+
1230
+
target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1231
+
if (!target_saddr) {
1232
+
return -TARGET_EFAULT;
1233
+
}
1234
+
1235
+
memcpy(addr, target_saddr, len);
1236
+
addr->sa_family = tswap16(target_saddr->sa_family);
1237
+
/* spkt_protocol is big-endian */
1238
+
1239
+
unlock_user(target_saddr, target_addr, 0);
1240
+
return 0;
1241
+
}
1242
+
1243
+
TargetFdTrans target_packet_trans = {
1244
+
.target_to_host_addr = packet_target_to_host_sockaddr,
1245
+
};
1246
+
1247
+
#ifdef CONFIG_RTNETLINK
1248
+
static abi_long netlink_route_target_to_host(void *buf, size_t len)
1249
+
{
1250
+
abi_long ret;
1251
+
1252
+
ret = target_to_host_nlmsg_route(buf, len);
1253
+
if (ret < 0) {
1254
+
return ret;
1255
+
}
1256
+
1257
+
return len;
1258
+
}
1259
+
1260
+
static abi_long netlink_route_host_to_target(void *buf, size_t len)
1261
+
{
1262
+
abi_long ret;
1263
+
1264
+
ret = host_to_target_nlmsg_route(buf, len);
1265
+
if (ret < 0) {
1266
+
return ret;
1267
+
}
1268
+
1269
+
return len;
1270
+
}
1271
+
1272
+
TargetFdTrans target_netlink_route_trans = {
1273
+
.target_to_host_data = netlink_route_target_to_host,
1274
+
.host_to_target_data = netlink_route_host_to_target,
1275
+
};
1276
+
#endif /* CONFIG_RTNETLINK */
1277
+
1278
+
static abi_long netlink_audit_target_to_host(void *buf, size_t len)
1279
+
{
1280
+
abi_long ret;
1281
+
1282
+
ret = target_to_host_nlmsg_audit(buf, len);
1283
+
if (ret < 0) {
1284
+
return ret;
1285
+
}
1286
+
1287
+
return len;
1288
+
}
1289
+
1290
+
static abi_long netlink_audit_host_to_target(void *buf, size_t len)
1291
+
{
1292
+
abi_long ret;
1293
+
1294
+
ret = host_to_target_nlmsg_audit(buf, len);
1295
+
if (ret < 0) {
1296
+
return ret;
1297
+
}
1298
+
1299
+
return len;
1300
+
}
1301
+
1302
+
TargetFdTrans target_netlink_audit_trans = {
1303
+
.target_to_host_data = netlink_audit_target_to_host,
1304
+
.host_to_target_data = netlink_audit_host_to_target,
1305
+
};
1306
+
1307
+
/* signalfd siginfo conversion */
1308
+
1309
+
static void
1310
+
host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo,
1311
+
const struct signalfd_siginfo *info)
1312
+
{
1313
+
int sig = host_to_target_signal(info->ssi_signo);
1314
+
1315
+
/* linux/signalfd.h defines a ssi_addr_lsb
1316
+
* not defined in sys/signalfd.h but used by some kernels
1317
+
*/
1318
+
1319
+
#ifdef BUS_MCEERR_AO
1320
+
if (tinfo->ssi_signo == SIGBUS &&
1321
+
(tinfo->ssi_code == BUS_MCEERR_AR ||
1322
+
tinfo->ssi_code == BUS_MCEERR_AO)) {
1323
+
uint16_t *ssi_addr_lsb = (uint16_t *)(&info->ssi_addr + 1);
1324
+
uint16_t *tssi_addr_lsb = (uint16_t *)(&tinfo->ssi_addr + 1);
1325
+
*tssi_addr_lsb = tswap16(*ssi_addr_lsb);
1326
+
}
1327
+
#endif
1328
+
1329
+
tinfo->ssi_signo = tswap32(sig);
1330
+
tinfo->ssi_errno = tswap32(tinfo->ssi_errno);
1331
+
tinfo->ssi_code = tswap32(info->ssi_code);
1332
+
tinfo->ssi_pid = tswap32(info->ssi_pid);
1333
+
tinfo->ssi_uid = tswap32(info->ssi_uid);
1334
+
tinfo->ssi_fd = tswap32(info->ssi_fd);
1335
+
tinfo->ssi_tid = tswap32(info->ssi_tid);
1336
+
tinfo->ssi_band = tswap32(info->ssi_band);
1337
+
tinfo->ssi_overrun = tswap32(info->ssi_overrun);
1338
+
tinfo->ssi_trapno = tswap32(info->ssi_trapno);
1339
+
tinfo->ssi_status = tswap32(info->ssi_status);
1340
+
tinfo->ssi_int = tswap32(info->ssi_int);
1341
+
tinfo->ssi_ptr = tswap64(info->ssi_ptr);
1342
+
tinfo->ssi_utime = tswap64(info->ssi_utime);
1343
+
tinfo->ssi_stime = tswap64(info->ssi_stime);
1344
+
tinfo->ssi_addr = tswap64(info->ssi_addr);
1345
+
}
1346
+
1347
+
static abi_long host_to_target_data_signalfd(void *buf, size_t len)
1348
+
{
1349
+
int i;
1350
+
1351
+
for (i = 0; i < len; i += sizeof(struct signalfd_siginfo)) {
1352
+
host_to_target_signalfd_siginfo(buf + i, buf + i);
1353
+
}
1354
+
1355
+
return len;
1356
+
}
1357
+
1358
+
TargetFdTrans target_signalfd_trans = {
1359
+
.host_to_target_data = host_to_target_data_signalfd,
1360
+
};
1361
+
1362
+
static abi_long swap_data_eventfd(void *buf, size_t len)
1363
+
{
1364
+
uint64_t *counter = buf;
1365
+
int i;
1366
+
1367
+
if (len < sizeof(uint64_t)) {
1368
+
return -EINVAL;
1369
+
}
1370
+
1371
+
for (i = 0; i < len; i += sizeof(uint64_t)) {
1372
+
*counter = tswap64(*counter);
1373
+
counter++;
1374
+
}
1375
+
1376
+
return len;
1377
+
}
1378
+
1379
+
TargetFdTrans target_eventfd_trans = {
1380
+
.host_to_target_data = swap_data_eventfd,
1381
+
.target_to_host_data = swap_data_eventfd,
1382
+
};
1383
+
1384
+
#if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \
1385
+
(defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \
1386
+
defined(__NR_inotify_init1))
1387
+
static abi_long host_to_target_data_inotify(void *buf, size_t len)
1388
+
{
1389
+
struct inotify_event *ev;
1390
+
int i;
1391
+
uint32_t name_len;
1392
+
1393
+
for (i = 0; i < len; i += sizeof(struct inotify_event) + name_len) {
1394
+
ev = (struct inotify_event *)((char *)buf + i);
1395
+
name_len = ev->len;
1396
+
1397
+
ev->wd = tswap32(ev->wd);
1398
+
ev->mask = tswap32(ev->mask);
1399
+
ev->cookie = tswap32(ev->cookie);
1400
+
ev->len = tswap32(name_len);
1401
+
}
1402
+
1403
+
return len;
1404
+
}
1405
+
1406
+
TargetFdTrans target_inotify_trans = {
1407
+
.host_to_target_data = host_to_target_data_inotify,
1408
+
};
1409
+
#endif
+97
linux-user/fd-trans.h
+97
linux-user/fd-trans.h
···
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
+
#ifndef FD_TRANS_H
17
+
#define FD_TRANS_H
18
+
19
+
typedef abi_long (*TargetFdDataFunc)(void *, size_t);
20
+
typedef abi_long (*TargetFdAddrFunc)(void *, abi_ulong, socklen_t);
21
+
typedef struct TargetFdTrans {
22
+
TargetFdDataFunc host_to_target_data;
23
+
TargetFdDataFunc target_to_host_data;
24
+
TargetFdAddrFunc target_to_host_addr;
25
+
} TargetFdTrans;
26
+
27
+
extern TargetFdTrans **target_fd_trans;
28
+
29
+
extern unsigned int target_fd_max;
30
+
31
+
static inline TargetFdDataFunc fd_trans_target_to_host_data(int fd)
32
+
{
33
+
if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
34
+
return target_fd_trans[fd]->target_to_host_data;
35
+
}
36
+
return NULL;
37
+
}
38
+
39
+
static inline TargetFdDataFunc fd_trans_host_to_target_data(int fd)
40
+
{
41
+
if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
42
+
return target_fd_trans[fd]->host_to_target_data;
43
+
}
44
+
return NULL;
45
+
}
46
+
47
+
static inline TargetFdAddrFunc fd_trans_target_to_host_addr(int fd)
48
+
{
49
+
if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
50
+
return target_fd_trans[fd]->target_to_host_addr;
51
+
}
52
+
return NULL;
53
+
}
54
+
55
+
static inline void fd_trans_register(int fd, TargetFdTrans *trans)
56
+
{
57
+
unsigned int oldmax;
58
+
59
+
if (fd >= target_fd_max) {
60
+
oldmax = target_fd_max;
61
+
target_fd_max = ((fd >> 6) + 1) << 6; /* by slice of 64 entries */
62
+
target_fd_trans = g_renew(TargetFdTrans *,
63
+
target_fd_trans, target_fd_max);
64
+
memset((void *)(target_fd_trans + oldmax), 0,
65
+
(target_fd_max - oldmax) * sizeof(TargetFdTrans *));
66
+
}
67
+
target_fd_trans[fd] = trans;
68
+
}
69
+
70
+
static inline void fd_trans_unregister(int fd)
71
+
{
72
+
if (fd >= 0 && fd < target_fd_max) {
73
+
target_fd_trans[fd] = NULL;
74
+
}
75
+
}
76
+
77
+
static inline void fd_trans_dup(int oldfd, int newfd)
78
+
{
79
+
fd_trans_unregister(newfd);
80
+
if (oldfd < target_fd_max && target_fd_trans[oldfd]) {
81
+
fd_trans_register(newfd, target_fd_trans[oldfd]);
82
+
}
83
+
}
84
+
85
+
extern TargetFdTrans target_packet_trans;
86
+
#ifdef CONFIG_RTNETLINK
87
+
extern TargetFdTrans target_netlink_route_trans;
88
+
#endif
89
+
extern TargetFdTrans target_netlink_audit_trans;
90
+
extern TargetFdTrans target_signalfd_trans;
91
+
extern TargetFdTrans target_eventfd_trans;
92
+
#if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \
93
+
(defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \
94
+
defined(__NR_inotify_init1))
95
+
extern TargetFdTrans target_inotify_trans;
96
+
#endif
97
+
#endif
+1
-1447
linux-user/syscall.c
+1
-1447
linux-user/syscall.c
···
102
102
#include <linux/blkpg.h>
103
103
#include <netpacket/packet.h>
104
104
#include <linux/netlink.h>
105
-
#ifdef CONFIG_RTNETLINK
106
-
#include <linux/rtnetlink.h>
107
-
#include <linux/if_bridge.h>
108
-
#endif
109
-
#include <linux/audit.h>
110
105
#include "linux_loop.h"
111
106
#include "uname.h"
112
107
113
108
#include "qemu.h"
109
+
#include "fd-trans.h"
114
110
115
111
#ifndef CLONE_IO
116
112
#define CLONE_IO 0x80000000 /* Clone io context */
···
359
355
#endif
360
356
{ 0, 0, 0, 0 }
361
357
};
362
-
363
-
enum {
364
-
QEMU_IFLA_BR_UNSPEC,
365
-
QEMU_IFLA_BR_FORWARD_DELAY,
366
-
QEMU_IFLA_BR_HELLO_TIME,
367
-
QEMU_IFLA_BR_MAX_AGE,
368
-
QEMU_IFLA_BR_AGEING_TIME,
369
-
QEMU_IFLA_BR_STP_STATE,
370
-
QEMU_IFLA_BR_PRIORITY,
371
-
QEMU_IFLA_BR_VLAN_FILTERING,
372
-
QEMU_IFLA_BR_VLAN_PROTOCOL,
373
-
QEMU_IFLA_BR_GROUP_FWD_MASK,
374
-
QEMU_IFLA_BR_ROOT_ID,
375
-
QEMU_IFLA_BR_BRIDGE_ID,
376
-
QEMU_IFLA_BR_ROOT_PORT,
377
-
QEMU_IFLA_BR_ROOT_PATH_COST,
378
-
QEMU_IFLA_BR_TOPOLOGY_CHANGE,
379
-
QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
380
-
QEMU_IFLA_BR_HELLO_TIMER,
381
-
QEMU_IFLA_BR_TCN_TIMER,
382
-
QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER,
383
-
QEMU_IFLA_BR_GC_TIMER,
384
-
QEMU_IFLA_BR_GROUP_ADDR,
385
-
QEMU_IFLA_BR_FDB_FLUSH,
386
-
QEMU_IFLA_BR_MCAST_ROUTER,
387
-
QEMU_IFLA_BR_MCAST_SNOOPING,
388
-
QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR,
389
-
QEMU_IFLA_BR_MCAST_QUERIER,
390
-
QEMU_IFLA_BR_MCAST_HASH_ELASTICITY,
391
-
QEMU_IFLA_BR_MCAST_HASH_MAX,
392
-
QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT,
393
-
QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT,
394
-
QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL,
395
-
QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL,
396
-
QEMU_IFLA_BR_MCAST_QUERIER_INTVL,
397
-
QEMU_IFLA_BR_MCAST_QUERY_INTVL,
398
-
QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL,
399
-
QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL,
400
-
QEMU_IFLA_BR_NF_CALL_IPTABLES,
401
-
QEMU_IFLA_BR_NF_CALL_IP6TABLES,
402
-
QEMU_IFLA_BR_NF_CALL_ARPTABLES,
403
-
QEMU_IFLA_BR_VLAN_DEFAULT_PVID,
404
-
QEMU_IFLA_BR_PAD,
405
-
QEMU_IFLA_BR_VLAN_STATS_ENABLED,
406
-
QEMU_IFLA_BR_MCAST_STATS_ENABLED,
407
-
QEMU_IFLA_BR_MCAST_IGMP_VERSION,
408
-
QEMU_IFLA_BR_MCAST_MLD_VERSION,
409
-
QEMU___IFLA_BR_MAX,
410
-
};
411
-
412
-
enum {
413
-
QEMU_IFLA_UNSPEC,
414
-
QEMU_IFLA_ADDRESS,
415
-
QEMU_IFLA_BROADCAST,
416
-
QEMU_IFLA_IFNAME,
417
-
QEMU_IFLA_MTU,
418
-
QEMU_IFLA_LINK,
419
-
QEMU_IFLA_QDISC,
420
-
QEMU_IFLA_STATS,
421
-
QEMU_IFLA_COST,
422
-
QEMU_IFLA_PRIORITY,
423
-
QEMU_IFLA_MASTER,
424
-
QEMU_IFLA_WIRELESS,
425
-
QEMU_IFLA_PROTINFO,
426
-
QEMU_IFLA_TXQLEN,
427
-
QEMU_IFLA_MAP,
428
-
QEMU_IFLA_WEIGHT,
429
-
QEMU_IFLA_OPERSTATE,
430
-
QEMU_IFLA_LINKMODE,
431
-
QEMU_IFLA_LINKINFO,
432
-
QEMU_IFLA_NET_NS_PID,
433
-
QEMU_IFLA_IFALIAS,
434
-
QEMU_IFLA_NUM_VF,
435
-
QEMU_IFLA_VFINFO_LIST,
436
-
QEMU_IFLA_STATS64,
437
-
QEMU_IFLA_VF_PORTS,
438
-
QEMU_IFLA_PORT_SELF,
439
-
QEMU_IFLA_AF_SPEC,
440
-
QEMU_IFLA_GROUP,
441
-
QEMU_IFLA_NET_NS_FD,
442
-
QEMU_IFLA_EXT_MASK,
443
-
QEMU_IFLA_PROMISCUITY,
444
-
QEMU_IFLA_NUM_TX_QUEUES,
445
-
QEMU_IFLA_NUM_RX_QUEUES,
446
-
QEMU_IFLA_CARRIER,
447
-
QEMU_IFLA_PHYS_PORT_ID,
448
-
QEMU_IFLA_CARRIER_CHANGES,
449
-
QEMU_IFLA_PHYS_SWITCH_ID,
450
-
QEMU_IFLA_LINK_NETNSID,
451
-
QEMU_IFLA_PHYS_PORT_NAME,
452
-
QEMU_IFLA_PROTO_DOWN,
453
-
QEMU_IFLA_GSO_MAX_SEGS,
454
-
QEMU_IFLA_GSO_MAX_SIZE,
455
-
QEMU_IFLA_PAD,
456
-
QEMU_IFLA_XDP,
457
-
QEMU_IFLA_EVENT,
458
-
QEMU_IFLA_NEW_NETNSID,
459
-
QEMU_IFLA_IF_NETNSID,
460
-
QEMU_IFLA_CARRIER_UP_COUNT,
461
-
QEMU_IFLA_CARRIER_DOWN_COUNT,
462
-
QEMU_IFLA_NEW_IFINDEX,
463
-
QEMU___IFLA_MAX
464
-
};
465
-
466
-
enum {
467
-
QEMU_IFLA_BRPORT_UNSPEC,
468
-
QEMU_IFLA_BRPORT_STATE,
469
-
QEMU_IFLA_BRPORT_PRIORITY,
470
-
QEMU_IFLA_BRPORT_COST,
471
-
QEMU_IFLA_BRPORT_MODE,
472
-
QEMU_IFLA_BRPORT_GUARD,
473
-
QEMU_IFLA_BRPORT_PROTECT,
474
-
QEMU_IFLA_BRPORT_FAST_LEAVE,
475
-
QEMU_IFLA_BRPORT_LEARNING,
476
-
QEMU_IFLA_BRPORT_UNICAST_FLOOD,
477
-
QEMU_IFLA_BRPORT_PROXYARP,
478
-
QEMU_IFLA_BRPORT_LEARNING_SYNC,
479
-
QEMU_IFLA_BRPORT_PROXYARP_WIFI,
480
-
QEMU_IFLA_BRPORT_ROOT_ID,
481
-
QEMU_IFLA_BRPORT_BRIDGE_ID,
482
-
QEMU_IFLA_BRPORT_DESIGNATED_PORT,
483
-
QEMU_IFLA_BRPORT_DESIGNATED_COST,
484
-
QEMU_IFLA_BRPORT_ID,
485
-
QEMU_IFLA_BRPORT_NO,
486
-
QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
487
-
QEMU_IFLA_BRPORT_CONFIG_PENDING,
488
-
QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER,
489
-
QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER,
490
-
QEMU_IFLA_BRPORT_HOLD_TIMER,
491
-
QEMU_IFLA_BRPORT_FLUSH,
492
-
QEMU_IFLA_BRPORT_MULTICAST_ROUTER,
493
-
QEMU_IFLA_BRPORT_PAD,
494
-
QEMU_IFLA_BRPORT_MCAST_FLOOD,
495
-
QEMU_IFLA_BRPORT_MCAST_TO_UCAST,
496
-
QEMU_IFLA_BRPORT_VLAN_TUNNEL,
497
-
QEMU_IFLA_BRPORT_BCAST_FLOOD,
498
-
QEMU_IFLA_BRPORT_GROUP_FWD_MASK,
499
-
QEMU_IFLA_BRPORT_NEIGH_SUPPRESS,
500
-
QEMU___IFLA_BRPORT_MAX
501
-
};
502
-
503
-
enum {
504
-
QEMU_IFLA_TUN_UNSPEC,
505
-
QEMU_IFLA_TUN_OWNER,
506
-
QEMU_IFLA_TUN_GROUP,
507
-
QEMU_IFLA_TUN_TYPE,
508
-
QEMU_IFLA_TUN_PI,
509
-
QEMU_IFLA_TUN_VNET_HDR,
510
-
QEMU_IFLA_TUN_PERSIST,
511
-
QEMU_IFLA_TUN_MULTI_QUEUE,
512
-
QEMU_IFLA_TUN_NUM_QUEUES,
513
-
QEMU_IFLA_TUN_NUM_DISABLED_QUEUES,
514
-
QEMU___IFLA_TUN_MAX,
515
-
};
516
-
517
-
enum {
518
-
QEMU_IFLA_INFO_UNSPEC,
519
-
QEMU_IFLA_INFO_KIND,
520
-
QEMU_IFLA_INFO_DATA,
521
-
QEMU_IFLA_INFO_XSTATS,
522
-
QEMU_IFLA_INFO_SLAVE_KIND,
523
-
QEMU_IFLA_INFO_SLAVE_DATA,
524
-
QEMU___IFLA_INFO_MAX,
525
-
};
526
-
527
-
enum {
528
-
QEMU_IFLA_INET_UNSPEC,
529
-
QEMU_IFLA_INET_CONF,
530
-
QEMU___IFLA_INET_MAX,
531
-
};
532
-
533
-
enum {
534
-
QEMU_IFLA_INET6_UNSPEC,
535
-
QEMU_IFLA_INET6_FLAGS,
536
-
QEMU_IFLA_INET6_CONF,
537
-
QEMU_IFLA_INET6_STATS,
538
-
QEMU_IFLA_INET6_MCAST,
539
-
QEMU_IFLA_INET6_CACHEINFO,
540
-
QEMU_IFLA_INET6_ICMP6STATS,
541
-
QEMU_IFLA_INET6_TOKEN,
542
-
QEMU_IFLA_INET6_ADDR_GEN_MODE,
543
-
QEMU___IFLA_INET6_MAX
544
-
};
545
-
546
-
enum {
547
-
QEMU_IFLA_XDP_UNSPEC,
548
-
QEMU_IFLA_XDP_FD,
549
-
QEMU_IFLA_XDP_ATTACHED,
550
-
QEMU_IFLA_XDP_FLAGS,
551
-
QEMU_IFLA_XDP_PROG_ID,
552
-
QEMU___IFLA_XDP_MAX,
553
-
};
554
-
555
-
enum {
556
-
QEMU_RTA_UNSPEC,
557
-
QEMU_RTA_DST,
558
-
QEMU_RTA_SRC,
559
-
QEMU_RTA_IIF,
560
-
QEMU_RTA_OIF,
561
-
QEMU_RTA_GATEWAY,
562
-
QEMU_RTA_PRIORITY,
563
-
QEMU_RTA_PREFSRC,
564
-
QEMU_RTA_METRICS,
565
-
QEMU_RTA_MULTIPATH,
566
-
QEMU_RTA_PROTOINFO, /* no longer used */
567
-
QEMU_RTA_FLOW,
568
-
QEMU_RTA_CACHEINFO,
569
-
QEMU_RTA_SESSION, /* no longer used */
570
-
QEMU_RTA_MP_ALGO, /* no longer used */
571
-
QEMU_RTA_TABLE,
572
-
QEMU_RTA_MARK,
573
-
QEMU_RTA_MFC_STATS,
574
-
QEMU_RTA_VIA,
575
-
QEMU_RTA_NEWDST,
576
-
QEMU_RTA_PREF,
577
-
QEMU_RTA_ENCAP_TYPE,
578
-
QEMU_RTA_ENCAP,
579
-
QEMU_RTA_EXPIRES,
580
-
QEMU_RTA_PAD,
581
-
QEMU_RTA_UID,
582
-
QEMU_RTA_TTL_PROPAGATE,
583
-
QEMU_RTA_IP_PROTO,
584
-
QEMU_RTA_SPORT,
585
-
QEMU_RTA_DPORT,
586
-
QEMU___RTA_MAX
587
-
};
588
-
589
-
typedef abi_long (*TargetFdDataFunc)(void *, size_t);
590
-
typedef abi_long (*TargetFdAddrFunc)(void *, abi_ulong, socklen_t);
591
-
typedef struct TargetFdTrans {
592
-
TargetFdDataFunc host_to_target_data;
593
-
TargetFdDataFunc target_to_host_data;
594
-
TargetFdAddrFunc target_to_host_addr;
595
-
} TargetFdTrans;
596
-
597
-
static TargetFdTrans **target_fd_trans;
598
-
599
-
static unsigned int target_fd_max;
600
-
601
-
static TargetFdDataFunc fd_trans_target_to_host_data(int fd)
602
-
{
603
-
if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
604
-
return target_fd_trans[fd]->target_to_host_data;
605
-
}
606
-
return NULL;
607
-
}
608
-
609
-
static TargetFdDataFunc fd_trans_host_to_target_data(int fd)
610
-
{
611
-
if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
612
-
return target_fd_trans[fd]->host_to_target_data;
613
-
}
614
-
return NULL;
615
-
}
616
-
617
-
static TargetFdAddrFunc fd_trans_target_to_host_addr(int fd)
618
-
{
619
-
if (fd >= 0 && fd < target_fd_max && target_fd_trans[fd]) {
620
-
return target_fd_trans[fd]->target_to_host_addr;
621
-
}
622
-
return NULL;
623
-
}
624
-
625
-
static void fd_trans_register(int fd, TargetFdTrans *trans)
626
-
{
627
-
unsigned int oldmax;
628
-
629
-
if (fd >= target_fd_max) {
630
-
oldmax = target_fd_max;
631
-
target_fd_max = ((fd >> 6) + 1) << 6; /* by slice of 64 entries */
632
-
target_fd_trans = g_renew(TargetFdTrans *,
633
-
target_fd_trans, target_fd_max);
634
-
memset((void *)(target_fd_trans + oldmax), 0,
635
-
(target_fd_max - oldmax) * sizeof(TargetFdTrans *));
636
-
}
637
-
target_fd_trans[fd] = trans;
638
-
}
639
-
640
-
static void fd_trans_unregister(int fd)
641
-
{
642
-
if (fd >= 0 && fd < target_fd_max) {
643
-
target_fd_trans[fd] = NULL;
644
-
}
645
-
}
646
-
647
-
static void fd_trans_dup(int oldfd, int newfd)
648
-
{
649
-
fd_trans_unregister(newfd);
650
-
if (oldfd < target_fd_max && target_fd_trans[oldfd]) {
651
-
fd_trans_register(newfd, target_fd_trans[oldfd]);
652
-
}
653
-
}
654
358
655
359
static int sys_getcwd1(char *buf, size_t size)
656
360
{
···
2076
1780
return 0;
2077
1781
}
2078
1782
2079
-
static void tswap_nlmsghdr(struct nlmsghdr *nlh)
2080
-
{
2081
-
nlh->nlmsg_len = tswap32(nlh->nlmsg_len);
2082
-
nlh->nlmsg_type = tswap16(nlh->nlmsg_type);
2083
-
nlh->nlmsg_flags = tswap16(nlh->nlmsg_flags);
2084
-
nlh->nlmsg_seq = tswap32(nlh->nlmsg_seq);
2085
-
nlh->nlmsg_pid = tswap32(nlh->nlmsg_pid);
2086
-
}
2087
-
2088
-
static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh,
2089
-
size_t len,
2090
-
abi_long (*host_to_target_nlmsg)
2091
-
(struct nlmsghdr *))
2092
-
{
2093
-
uint32_t nlmsg_len;
2094
-
abi_long ret;
2095
-
2096
-
while (len > sizeof(struct nlmsghdr)) {
2097
-
2098
-
nlmsg_len = nlh->nlmsg_len;
2099
-
if (nlmsg_len < sizeof(struct nlmsghdr) ||
2100
-
nlmsg_len > len) {
2101
-
break;
2102
-
}
2103
-
2104
-
switch (nlh->nlmsg_type) {
2105
-
case NLMSG_DONE:
2106
-
tswap_nlmsghdr(nlh);
2107
-
return 0;
2108
-
case NLMSG_NOOP:
2109
-
break;
2110
-
case NLMSG_ERROR:
2111
-
{
2112
-
struct nlmsgerr *e = NLMSG_DATA(nlh);
2113
-
e->error = tswap32(e->error);
2114
-
tswap_nlmsghdr(&e->msg);
2115
-
tswap_nlmsghdr(nlh);
2116
-
return 0;
2117
-
}
2118
-
default:
2119
-
ret = host_to_target_nlmsg(nlh);
2120
-
if (ret < 0) {
2121
-
tswap_nlmsghdr(nlh);
2122
-
return ret;
2123
-
}
2124
-
break;
2125
-
}
2126
-
tswap_nlmsghdr(nlh);
2127
-
len -= NLMSG_ALIGN(nlmsg_len);
2128
-
nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len));
2129
-
}
2130
-
return 0;
2131
-
}
2132
-
2133
-
static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh,
2134
-
size_t len,
2135
-
abi_long (*target_to_host_nlmsg)
2136
-
(struct nlmsghdr *))
2137
-
{
2138
-
int ret;
2139
-
2140
-
while (len > sizeof(struct nlmsghdr)) {
2141
-
if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) ||
2142
-
tswap32(nlh->nlmsg_len) > len) {
2143
-
break;
2144
-
}
2145
-
tswap_nlmsghdr(nlh);
2146
-
switch (nlh->nlmsg_type) {
2147
-
case NLMSG_DONE:
2148
-
return 0;
2149
-
case NLMSG_NOOP:
2150
-
break;
2151
-
case NLMSG_ERROR:
2152
-
{
2153
-
struct nlmsgerr *e = NLMSG_DATA(nlh);
2154
-
e->error = tswap32(e->error);
2155
-
tswap_nlmsghdr(&e->msg);
2156
-
return 0;
2157
-
}
2158
-
default:
2159
-
ret = target_to_host_nlmsg(nlh);
2160
-
if (ret < 0) {
2161
-
return ret;
2162
-
}
2163
-
}
2164
-
len -= NLMSG_ALIGN(nlh->nlmsg_len);
2165
-
nlh = (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg_len));
2166
-
}
2167
-
return 0;
2168
-
}
2169
-
2170
-
#ifdef CONFIG_RTNETLINK
2171
-
static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr,
2172
-
size_t len, void *context,
2173
-
abi_long (*host_to_target_nlattr)
2174
-
(struct nlattr *,
2175
-
void *context))
2176
-
{
2177
-
unsigned short nla_len;
2178
-
abi_long ret;
2179
-
2180
-
while (len > sizeof(struct nlattr)) {
2181
-
nla_len = nlattr->nla_len;
2182
-
if (nla_len < sizeof(struct nlattr) ||
2183
-
nla_len > len) {
2184
-
break;
2185
-
}
2186
-
ret = host_to_target_nlattr(nlattr, context);
2187
-
nlattr->nla_len = tswap16(nlattr->nla_len);
2188
-
nlattr->nla_type = tswap16(nlattr->nla_type);
2189
-
if (ret < 0) {
2190
-
return ret;
2191
-
}
2192
-
len -= NLA_ALIGN(nla_len);
2193
-
nlattr = (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len));
2194
-
}
2195
-
return 0;
2196
-
}
2197
-
2198
-
static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr,
2199
-
size_t len,
2200
-
abi_long (*host_to_target_rtattr)
2201
-
(struct rtattr *))
2202
-
{
2203
-
unsigned short rta_len;
2204
-
abi_long ret;
2205
-
2206
-
while (len > sizeof(struct rtattr)) {
2207
-
rta_len = rtattr->rta_len;
2208
-
if (rta_len < sizeof(struct rtattr) ||
2209
-
rta_len > len) {
2210
-
break;
2211
-
}
2212
-
ret = host_to_target_rtattr(rtattr);
2213
-
rtattr->rta_len = tswap16(rtattr->rta_len);
2214
-
rtattr->rta_type = tswap16(rtattr->rta_type);
2215
-
if (ret < 0) {
2216
-
return ret;
2217
-
}
2218
-
len -= RTA_ALIGN(rta_len);
2219
-
rtattr = (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len));
2220
-
}
2221
-
return 0;
2222
-
}
2223
-
2224
-
#define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN)
2225
-
2226
-
static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr,
2227
-
void *context)
2228
-
{
2229
-
uint16_t *u16;
2230
-
uint32_t *u32;
2231
-
uint64_t *u64;
2232
-
2233
-
switch (nlattr->nla_type) {
2234
-
/* no data */
2235
-
case QEMU_IFLA_BR_FDB_FLUSH:
2236
-
break;
2237
-
/* binary */
2238
-
case QEMU_IFLA_BR_GROUP_ADDR:
2239
-
break;
2240
-
/* uint8_t */
2241
-
case QEMU_IFLA_BR_VLAN_FILTERING:
2242
-
case QEMU_IFLA_BR_TOPOLOGY_CHANGE:
2243
-
case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED:
2244
-
case QEMU_IFLA_BR_MCAST_ROUTER:
2245
-
case QEMU_IFLA_BR_MCAST_SNOOPING:
2246
-
case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR:
2247
-
case QEMU_IFLA_BR_MCAST_QUERIER:
2248
-
case QEMU_IFLA_BR_NF_CALL_IPTABLES:
2249
-
case QEMU_IFLA_BR_NF_CALL_IP6TABLES:
2250
-
case QEMU_IFLA_BR_NF_CALL_ARPTABLES:
2251
-
case QEMU_IFLA_BR_VLAN_STATS_ENABLED:
2252
-
case QEMU_IFLA_BR_MCAST_STATS_ENABLED:
2253
-
case QEMU_IFLA_BR_MCAST_IGMP_VERSION:
2254
-
case QEMU_IFLA_BR_MCAST_MLD_VERSION:
2255
-
break;
2256
-
/* uint16_t */
2257
-
case QEMU_IFLA_BR_PRIORITY:
2258
-
case QEMU_IFLA_BR_VLAN_PROTOCOL:
2259
-
case QEMU_IFLA_BR_GROUP_FWD_MASK:
2260
-
case QEMU_IFLA_BR_ROOT_PORT:
2261
-
case QEMU_IFLA_BR_VLAN_DEFAULT_PVID:
2262
-
u16 = NLA_DATA(nlattr);
2263
-
*u16 = tswap16(*u16);
2264
-
break;
2265
-
/* uint32_t */
2266
-
case QEMU_IFLA_BR_FORWARD_DELAY:
2267
-
case QEMU_IFLA_BR_HELLO_TIME:
2268
-
case QEMU_IFLA_BR_MAX_AGE:
2269
-
case QEMU_IFLA_BR_AGEING_TIME:
2270
-
case QEMU_IFLA_BR_STP_STATE:
2271
-
case QEMU_IFLA_BR_ROOT_PATH_COST:
2272
-
case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY:
2273
-
case QEMU_IFLA_BR_MCAST_HASH_MAX:
2274
-
case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT:
2275
-
case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT:
2276
-
u32 = NLA_DATA(nlattr);
2277
-
*u32 = tswap32(*u32);
2278
-
break;
2279
-
/* uint64_t */
2280
-
case QEMU_IFLA_BR_HELLO_TIMER:
2281
-
case QEMU_IFLA_BR_TCN_TIMER:
2282
-
case QEMU_IFLA_BR_GC_TIMER:
2283
-
case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER:
2284
-
case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL:
2285
-
case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL:
2286
-
case QEMU_IFLA_BR_MCAST_QUERIER_INTVL:
2287
-
case QEMU_IFLA_BR_MCAST_QUERY_INTVL:
2288
-
case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL:
2289
-
case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL:
2290
-
u64 = NLA_DATA(nlattr);
2291
-
*u64 = tswap64(*u64);
2292
-
break;
2293
-
/* ifla_bridge_id: uin8_t[] */
2294
-
case QEMU_IFLA_BR_ROOT_ID:
2295
-
case QEMU_IFLA_BR_BRIDGE_ID:
2296
-
break;
2297
-
default:
2298
-
gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr->nla_type);
2299
-
break;
2300
-
}
2301
-
return 0;
2302
-
}
2303
-
2304
-
static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nlattr,
2305
-
void *context)
2306
-
{
2307
-
uint16_t *u16;
2308
-
uint32_t *u32;
2309
-
uint64_t *u64;
2310
-
2311
-
switch (nlattr->nla_type) {
2312
-
/* uint8_t */
2313
-
case QEMU_IFLA_BRPORT_STATE:
2314
-
case QEMU_IFLA_BRPORT_MODE:
2315
-
case QEMU_IFLA_BRPORT_GUARD:
2316
-
case QEMU_IFLA_BRPORT_PROTECT:
2317
-
case QEMU_IFLA_BRPORT_FAST_LEAVE:
2318
-
case QEMU_IFLA_BRPORT_LEARNING:
2319
-
case QEMU_IFLA_BRPORT_UNICAST_FLOOD:
2320
-
case QEMU_IFLA_BRPORT_PROXYARP:
2321
-
case QEMU_IFLA_BRPORT_LEARNING_SYNC:
2322
-
case QEMU_IFLA_BRPORT_PROXYARP_WIFI:
2323
-
case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK:
2324
-
case QEMU_IFLA_BRPORT_CONFIG_PENDING:
2325
-
case QEMU_IFLA_BRPORT_MULTICAST_ROUTER:
2326
-
case QEMU_IFLA_BRPORT_MCAST_FLOOD:
2327
-
case QEMU_IFLA_BRPORT_MCAST_TO_UCAST:
2328
-
case QEMU_IFLA_BRPORT_VLAN_TUNNEL:
2329
-
case QEMU_IFLA_BRPORT_BCAST_FLOOD:
2330
-
case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS:
2331
-
break;
2332
-
/* uint16_t */
2333
-
case QEMU_IFLA_BRPORT_PRIORITY:
2334
-
case QEMU_IFLA_BRPORT_DESIGNATED_PORT:
2335
-
case QEMU_IFLA_BRPORT_DESIGNATED_COST:
2336
-
case QEMU_IFLA_BRPORT_ID:
2337
-
case QEMU_IFLA_BRPORT_NO:
2338
-
case QEMU_IFLA_BRPORT_GROUP_FWD_MASK:
2339
-
u16 = NLA_DATA(nlattr);
2340
-
*u16 = tswap16(*u16);
2341
-
break;
2342
-
/* uin32_t */
2343
-
case QEMU_IFLA_BRPORT_COST:
2344
-
u32 = NLA_DATA(nlattr);
2345
-
*u32 = tswap32(*u32);
2346
-
break;
2347
-
/* uint64_t */
2348
-
case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER:
2349
-
case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER:
2350
-
case QEMU_IFLA_BRPORT_HOLD_TIMER:
2351
-
u64 = NLA_DATA(nlattr);
2352
-
*u64 = tswap64(*u64);
2353
-
break;
2354
-
/* ifla_bridge_id: uint8_t[] */
2355
-
case QEMU_IFLA_BRPORT_ROOT_ID:
2356
-
case QEMU_IFLA_BRPORT_BRIDGE_ID:
2357
-
break;
2358
-
default:
2359
-
gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr->nla_type);
2360
-
break;
2361
-
}
2362
-
return 0;
2363
-
}
2364
-
2365
-
static abi_long host_to_target_data_tun_nlattr(struct nlattr *nlattr,
2366
-
void *context)
2367
-
{
2368
-
uint32_t *u32;
2369
-
2370
-
switch (nlattr->nla_type) {
2371
-
/* uint8_t */
2372
-
case QEMU_IFLA_TUN_TYPE:
2373
-
case QEMU_IFLA_TUN_PI:
2374
-
case QEMU_IFLA_TUN_VNET_HDR:
2375
-
case QEMU_IFLA_TUN_PERSIST:
2376
-
case QEMU_IFLA_TUN_MULTI_QUEUE:
2377
-
break;
2378
-
/* uint32_t */
2379
-
case QEMU_IFLA_TUN_NUM_QUEUES:
2380
-
case QEMU_IFLA_TUN_NUM_DISABLED_QUEUES:
2381
-
case QEMU_IFLA_TUN_OWNER:
2382
-
case QEMU_IFLA_TUN_GROUP:
2383
-
u32 = NLA_DATA(nlattr);
2384
-
*u32 = tswap32(*u32);
2385
-
break;
2386
-
default:
2387
-
gemu_log("Unknown QEMU_IFLA_TUN type %d\n", nlattr->nla_type);
2388
-
break;
2389
-
}
2390
-
return 0;
2391
-
}
2392
-
2393
-
struct linkinfo_context {
2394
-
int len;
2395
-
char *name;
2396
-
int slave_len;
2397
-
char *slave_name;
2398
-
};
2399
-
2400
-
static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr,
2401
-
void *context)
2402
-
{
2403
-
struct linkinfo_context *li_context = context;
2404
-
2405
-
switch (nlattr->nla_type) {
2406
-
/* string */
2407
-
case QEMU_IFLA_INFO_KIND:
2408
-
li_context->name = NLA_DATA(nlattr);
2409
-
li_context->len = nlattr->nla_len - NLA_HDRLEN;
2410
-
break;
2411
-
case QEMU_IFLA_INFO_SLAVE_KIND:
2412
-
li_context->slave_name = NLA_DATA(nlattr);
2413
-
li_context->slave_len = nlattr->nla_len - NLA_HDRLEN;
2414
-
break;
2415
-
/* stats */
2416
-
case QEMU_IFLA_INFO_XSTATS:
2417
-
/* FIXME: only used by CAN */
2418
-
break;
2419
-
/* nested */
2420
-
case QEMU_IFLA_INFO_DATA:
2421
-
if (strncmp(li_context->name, "bridge",
2422
-
li_context->len) == 0) {
2423
-
return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
2424
-
nlattr->nla_len,
2425
-
NULL,
2426
-
host_to_target_data_bridge_nlattr);
2427
-
} else if (strncmp(li_context->name, "tun",
2428
-
li_context->len) == 0) {
2429
-
return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
2430
-
nlattr->nla_len,
2431
-
NULL,
2432
-
host_to_target_data_tun_nlattr);
2433
-
} else {
2434
-
gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context->name);
2435
-
}
2436
-
break;
2437
-
case QEMU_IFLA_INFO_SLAVE_DATA:
2438
-
if (strncmp(li_context->slave_name, "bridge",
2439
-
li_context->slave_len) == 0) {
2440
-
return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
2441
-
nlattr->nla_len,
2442
-
NULL,
2443
-
host_to_target_slave_data_bridge_nlattr);
2444
-
} else {
2445
-
gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n",
2446
-
li_context->slave_name);
2447
-
}
2448
-
break;
2449
-
default:
2450
-
gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr->nla_type);
2451
-
break;
2452
-
}
2453
-
2454
-
return 0;
2455
-
}
2456
-
2457
-
static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr,
2458
-
void *context)
2459
-
{
2460
-
uint32_t *u32;
2461
-
int i;
2462
-
2463
-
switch (nlattr->nla_type) {
2464
-
case QEMU_IFLA_INET_CONF:
2465
-
u32 = NLA_DATA(nlattr);
2466
-
for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
2467
-
i++) {
2468
-
u32[i] = tswap32(u32[i]);
2469
-
}
2470
-
break;
2471
-
default:
2472
-
gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type);
2473
-
}
2474
-
return 0;
2475
-
}
2476
-
2477
-
static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr,
2478
-
void *context)
2479
-
{
2480
-
uint32_t *u32;
2481
-
uint64_t *u64;
2482
-
struct ifla_cacheinfo *ci;
2483
-
int i;
2484
-
2485
-
switch (nlattr->nla_type) {
2486
-
/* binaries */
2487
-
case QEMU_IFLA_INET6_TOKEN:
2488
-
break;
2489
-
/* uint8_t */
2490
-
case QEMU_IFLA_INET6_ADDR_GEN_MODE:
2491
-
break;
2492
-
/* uint32_t */
2493
-
case QEMU_IFLA_INET6_FLAGS:
2494
-
u32 = NLA_DATA(nlattr);
2495
-
*u32 = tswap32(*u32);
2496
-
break;
2497
-
/* uint32_t[] */
2498
-
case QEMU_IFLA_INET6_CONF:
2499
-
u32 = NLA_DATA(nlattr);
2500
-
for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
2501
-
i++) {
2502
-
u32[i] = tswap32(u32[i]);
2503
-
}
2504
-
break;
2505
-
/* ifla_cacheinfo */
2506
-
case QEMU_IFLA_INET6_CACHEINFO:
2507
-
ci = NLA_DATA(nlattr);
2508
-
ci->max_reasm_len = tswap32(ci->max_reasm_len);
2509
-
ci->tstamp = tswap32(ci->tstamp);
2510
-
ci->reachable_time = tswap32(ci->reachable_time);
2511
-
ci->retrans_time = tswap32(ci->retrans_time);
2512
-
break;
2513
-
/* uint64_t[] */
2514
-
case QEMU_IFLA_INET6_STATS:
2515
-
case QEMU_IFLA_INET6_ICMP6STATS:
2516
-
u64 = NLA_DATA(nlattr);
2517
-
for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64);
2518
-
i++) {
2519
-
u64[i] = tswap64(u64[i]);
2520
-
}
2521
-
break;
2522
-
default:
2523
-
gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type);
2524
-
}
2525
-
return 0;
2526
-
}
2527
-
2528
-
static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr,
2529
-
void *context)
2530
-
{
2531
-
switch (nlattr->nla_type) {
2532
-
case AF_INET:
2533
-
return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
2534
-
NULL,
2535
-
host_to_target_data_inet_nlattr);
2536
-
case AF_INET6:
2537
-
return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
2538
-
NULL,
2539
-
host_to_target_data_inet6_nlattr);
2540
-
default:
2541
-
gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type);
2542
-
break;
2543
-
}
2544
-
return 0;
2545
-
}
2546
-
2547
-
static abi_long host_to_target_data_xdp_nlattr(struct nlattr *nlattr,
2548
-
void *context)
2549
-
{
2550
-
uint32_t *u32;
2551
-
2552
-
switch (nlattr->nla_type) {
2553
-
/* uint8_t */
2554
-
case QEMU_IFLA_XDP_ATTACHED:
2555
-
break;
2556
-
/* uint32_t */
2557
-
case QEMU_IFLA_XDP_PROG_ID:
2558
-
u32 = NLA_DATA(nlattr);
2559
-
*u32 = tswap32(*u32);
2560
-
break;
2561
-
default:
2562
-
gemu_log("Unknown host XDP type: %d\n", nlattr->nla_type);
2563
-
break;
2564
-
}
2565
-
return 0;
2566
-
}
2567
-
2568
-
static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr)
2569
-
{
2570
-
uint32_t *u32;
2571
-
struct rtnl_link_stats *st;
2572
-
struct rtnl_link_stats64 *st64;
2573
-
struct rtnl_link_ifmap *map;
2574
-
struct linkinfo_context li_context;
2575
-
2576
-
switch (rtattr->rta_type) {
2577
-
/* binary stream */
2578
-
case QEMU_IFLA_ADDRESS:
2579
-
case QEMU_IFLA_BROADCAST:
2580
-
/* string */
2581
-
case QEMU_IFLA_IFNAME:
2582
-
case QEMU_IFLA_QDISC:
2583
-
break;
2584
-
/* uin8_t */
2585
-
case QEMU_IFLA_OPERSTATE:
2586
-
case QEMU_IFLA_LINKMODE:
2587
-
case QEMU_IFLA_CARRIER:
2588
-
case QEMU_IFLA_PROTO_DOWN:
2589
-
break;
2590
-
/* uint32_t */
2591
-
case QEMU_IFLA_MTU:
2592
-
case QEMU_IFLA_LINK:
2593
-
case QEMU_IFLA_WEIGHT:
2594
-
case QEMU_IFLA_TXQLEN:
2595
-
case QEMU_IFLA_CARRIER_CHANGES:
2596
-
case QEMU_IFLA_NUM_RX_QUEUES:
2597
-
case QEMU_IFLA_NUM_TX_QUEUES:
2598
-
case QEMU_IFLA_PROMISCUITY:
2599
-
case QEMU_IFLA_EXT_MASK:
2600
-
case QEMU_IFLA_LINK_NETNSID:
2601
-
case QEMU_IFLA_GROUP:
2602
-
case QEMU_IFLA_MASTER:
2603
-
case QEMU_IFLA_NUM_VF:
2604
-
case QEMU_IFLA_GSO_MAX_SEGS:
2605
-
case QEMU_IFLA_GSO_MAX_SIZE:
2606
-
case QEMU_IFLA_CARRIER_UP_COUNT:
2607
-
case QEMU_IFLA_CARRIER_DOWN_COUNT:
2608
-
u32 = RTA_DATA(rtattr);
2609
-
*u32 = tswap32(*u32);
2610
-
break;
2611
-
/* struct rtnl_link_stats */
2612
-
case QEMU_IFLA_STATS:
2613
-
st = RTA_DATA(rtattr);
2614
-
st->rx_packets = tswap32(st->rx_packets);
2615
-
st->tx_packets = tswap32(st->tx_packets);
2616
-
st->rx_bytes = tswap32(st->rx_bytes);
2617
-
st->tx_bytes = tswap32(st->tx_bytes);
2618
-
st->rx_errors = tswap32(st->rx_errors);
2619
-
st->tx_errors = tswap32(st->tx_errors);
2620
-
st->rx_dropped = tswap32(st->rx_dropped);
2621
-
st->tx_dropped = tswap32(st->tx_dropped);
2622
-
st->multicast = tswap32(st->multicast);
2623
-
st->collisions = tswap32(st->collisions);
2624
-
2625
-
/* detailed rx_errors: */
2626
-
st->rx_length_errors = tswap32(st->rx_length_errors);
2627
-
st->rx_over_errors = tswap32(st->rx_over_errors);
2628
-
st->rx_crc_errors = tswap32(st->rx_crc_errors);
2629
-
st->rx_frame_errors = tswap32(st->rx_frame_errors);
2630
-
st->rx_fifo_errors = tswap32(st->rx_fifo_errors);
2631
-
st->rx_missed_errors = tswap32(st->rx_missed_errors);
2632
-
2633
-
/* detailed tx_errors */
2634
-
st->tx_aborted_errors = tswap32(st->tx_aborted_errors);
2635
-
st->tx_carrier_errors = tswap32(st->tx_carrier_errors);
2636
-
st->tx_fifo_errors = tswap32(st->tx_fifo_errors);
2637
-
st->tx_heartbeat_errors = tswap32(st->tx_heartbeat_errors);
2638
-
st->tx_window_errors = tswap32(st->tx_window_errors);
2639
-
2640
-
/* for cslip etc */
2641
-
st->rx_compressed = tswap32(st->rx_compressed);
2642
-
st->tx_compressed = tswap32(st->tx_compressed);
2643
-
break;
2644
-
/* struct rtnl_link_stats64 */
2645
-
case QEMU_IFLA_STATS64:
2646
-
st64 = RTA_DATA(rtattr);
2647
-
st64->rx_packets = tswap64(st64->rx_packets);
2648
-
st64->tx_packets = tswap64(st64->tx_packets);
2649
-
st64->rx_bytes = tswap64(st64->rx_bytes);
2650
-
st64->tx_bytes = tswap64(st64->tx_bytes);
2651
-
st64->rx_errors = tswap64(st64->rx_errors);
2652
-
st64->tx_errors = tswap64(st64->tx_errors);
2653
-
st64->rx_dropped = tswap64(st64->rx_dropped);
2654
-
st64->tx_dropped = tswap64(st64->tx_dropped);
2655
-
st64->multicast = tswap64(st64->multicast);
2656
-
st64->collisions = tswap64(st64->collisions);
2657
-
2658
-
/* detailed rx_errors: */
2659
-
st64->rx_length_errors = tswap64(st64->rx_length_errors);
2660
-
st64->rx_over_errors = tswap64(st64->rx_over_errors);
2661
-
st64->rx_crc_errors = tswap64(st64->rx_crc_errors);
2662
-
st64->rx_frame_errors = tswap64(st64->rx_frame_errors);
2663
-
st64->rx_fifo_errors = tswap64(st64->rx_fifo_errors);
2664
-
st64->rx_missed_errors = tswap64(st64->rx_missed_errors);
2665
-
2666
-
/* detailed tx_errors */
2667
-
st64->tx_aborted_errors = tswap64(st64->tx_aborted_errors);
2668
-
st64->tx_carrier_errors = tswap64(st64->tx_carrier_errors);
2669
-
st64->tx_fifo_errors = tswap64(st64->tx_fifo_errors);
2670
-
st64->tx_heartbeat_errors = tswap64(st64->tx_heartbeat_errors);
2671
-
st64->tx_window_errors = tswap64(st64->tx_window_errors);
2672
-
2673
-
/* for cslip etc */
2674
-
st64->rx_compressed = tswap64(st64->rx_compressed);
2675
-
st64->tx_compressed = tswap64(st64->tx_compressed);
2676
-
break;
2677
-
/* struct rtnl_link_ifmap */
2678
-
case QEMU_IFLA_MAP:
2679
-
map = RTA_DATA(rtattr);
2680
-
map->mem_start = tswap64(map->mem_start);
2681
-
map->mem_end = tswap64(map->mem_end);
2682
-
map->base_addr = tswap64(map->base_addr);
2683
-
map->irq = tswap16(map->irq);
2684
-
break;
2685
-
/* nested */
2686
-
case QEMU_IFLA_LINKINFO:
2687
-
memset(&li_context, 0, sizeof(li_context));
2688
-
return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
2689
-
&li_context,
2690
-
host_to_target_data_linkinfo_nlattr);
2691
-
case QEMU_IFLA_AF_SPEC:
2692
-
return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
2693
-
NULL,
2694
-
host_to_target_data_spec_nlattr);
2695
-
case QEMU_IFLA_XDP:
2696
-
return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
2697
-
NULL,
2698
-
host_to_target_data_xdp_nlattr);
2699
-
default:
2700
-
gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr->rta_type);
2701
-
break;
2702
-
}
2703
-
return 0;
2704
-
}
2705
-
2706
-
static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr)
2707
-
{
2708
-
uint32_t *u32;
2709
-
struct ifa_cacheinfo *ci;
2710
-
2711
-
switch (rtattr->rta_type) {
2712
-
/* binary: depends on family type */
2713
-
case IFA_ADDRESS:
2714
-
case IFA_LOCAL:
2715
-
break;
2716
-
/* string */
2717
-
case IFA_LABEL:
2718
-
break;
2719
-
/* u32 */
2720
-
case IFA_FLAGS:
2721
-
case IFA_BROADCAST:
2722
-
u32 = RTA_DATA(rtattr);
2723
-
*u32 = tswap32(*u32);
2724
-
break;
2725
-
/* struct ifa_cacheinfo */
2726
-
case IFA_CACHEINFO:
2727
-
ci = RTA_DATA(rtattr);
2728
-
ci->ifa_prefered = tswap32(ci->ifa_prefered);
2729
-
ci->ifa_valid = tswap32(ci->ifa_valid);
2730
-
ci->cstamp = tswap32(ci->cstamp);
2731
-
ci->tstamp = tswap32(ci->tstamp);
2732
-
break;
2733
-
default:
2734
-
gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type);
2735
-
break;
2736
-
}
2737
-
return 0;
2738
-
}
2739
-
2740
-
static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr)
2741
-
{
2742
-
uint32_t *u32;
2743
-
struct rta_cacheinfo *ci;
2744
-
2745
-
switch (rtattr->rta_type) {
2746
-
/* binary: depends on family type */
2747
-
case QEMU_RTA_GATEWAY:
2748
-
case QEMU_RTA_DST:
2749
-
case QEMU_RTA_PREFSRC:
2750
-
break;
2751
-
/* u8 */
2752
-
case QEMU_RTA_PREF:
2753
-
break;
2754
-
/* u32 */
2755
-
case QEMU_RTA_PRIORITY:
2756
-
case QEMU_RTA_TABLE:
2757
-
case QEMU_RTA_OIF:
2758
-
u32 = RTA_DATA(rtattr);
2759
-
*u32 = tswap32(*u32);
2760
-
break;
2761
-
/* struct rta_cacheinfo */
2762
-
case QEMU_RTA_CACHEINFO:
2763
-
ci = RTA_DATA(rtattr);
2764
-
ci->rta_clntref = tswap32(ci->rta_clntref);
2765
-
ci->rta_lastuse = tswap32(ci->rta_lastuse);
2766
-
ci->rta_expires = tswap32(ci->rta_expires);
2767
-
ci->rta_error = tswap32(ci->rta_error);
2768
-
ci->rta_used = tswap32(ci->rta_used);
2769
-
#if defined(RTNETLINK_HAVE_PEERINFO)
2770
-
ci->rta_id = tswap32(ci->rta_id);
2771
-
ci->rta_ts = tswap32(ci->rta_ts);
2772
-
ci->rta_tsage = tswap32(ci->rta_tsage);
2773
-
#endif
2774
-
break;
2775
-
default:
2776
-
gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type);
2777
-
break;
2778
-
}
2779
-
return 0;
2780
-
}
2781
-
2782
-
static abi_long host_to_target_link_rtattr(struct rtattr *rtattr,
2783
-
uint32_t rtattr_len)
2784
-
{
2785
-
return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2786
-
host_to_target_data_link_rtattr);
2787
-
}
2788
-
2789
-
static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr,
2790
-
uint32_t rtattr_len)
2791
-
{
2792
-
return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2793
-
host_to_target_data_addr_rtattr);
2794
-
}
2795
-
2796
-
static abi_long host_to_target_route_rtattr(struct rtattr *rtattr,
2797
-
uint32_t rtattr_len)
2798
-
{
2799
-
return host_to_target_for_each_rtattr(rtattr, rtattr_len,
2800
-
host_to_target_data_route_rtattr);
2801
-
}
2802
-
2803
-
static abi_long host_to_target_data_route(struct nlmsghdr *nlh)
2804
-
{
2805
-
uint32_t nlmsg_len;
2806
-
struct ifinfomsg *ifi;
2807
-
struct ifaddrmsg *ifa;
2808
-
struct rtmsg *rtm;
2809
-
2810
-
nlmsg_len = nlh->nlmsg_len;
2811
-
switch (nlh->nlmsg_type) {
2812
-
case RTM_NEWLINK:
2813
-
case RTM_DELLINK:
2814
-
case RTM_GETLINK:
2815
-
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
2816
-
ifi = NLMSG_DATA(nlh);
2817
-
ifi->ifi_type = tswap16(ifi->ifi_type);
2818
-
ifi->ifi_index = tswap32(ifi->ifi_index);
2819
-
ifi->ifi_flags = tswap32(ifi->ifi_flags);
2820
-
ifi->ifi_change = tswap32(ifi->ifi_change);
2821
-
host_to_target_link_rtattr(IFLA_RTA(ifi),
2822
-
nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));
2823
-
}
2824
-
break;
2825
-
case RTM_NEWADDR:
2826
-
case RTM_DELADDR:
2827
-
case RTM_GETADDR:
2828
-
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
2829
-
ifa = NLMSG_DATA(nlh);
2830
-
ifa->ifa_index = tswap32(ifa->ifa_index);
2831
-
host_to_target_addr_rtattr(IFA_RTA(ifa),
2832
-
nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
2833
-
}
2834
-
break;
2835
-
case RTM_NEWROUTE:
2836
-
case RTM_DELROUTE:
2837
-
case RTM_GETROUTE:
2838
-
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
2839
-
rtm = NLMSG_DATA(nlh);
2840
-
rtm->rtm_flags = tswap32(rtm->rtm_flags);
2841
-
host_to_target_route_rtattr(RTM_RTA(rtm),
2842
-
nlmsg_len - NLMSG_LENGTH(sizeof(*rtm)));
2843
-
}
2844
-
break;
2845
-
default:
2846
-
return -TARGET_EINVAL;
2847
-
}
2848
-
return 0;
2849
-
}
2850
-
2851
-
static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh,
2852
-
size_t len)
2853
-
{
2854
-
return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_route);
2855
-
}
2856
-
2857
-
static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
2858
-
size_t len,
2859
-
abi_long (*target_to_host_rtattr)
2860
-
(struct rtattr *))
2861
-
{
2862
-
abi_long ret;
2863
-
2864
-
while (len >= sizeof(struct rtattr)) {
2865
-
if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) ||
2866
-
tswap16(rtattr->rta_len) > len) {
2867
-
break;
2868
-
}
2869
-
rtattr->rta_len = tswap16(rtattr->rta_len);
2870
-
rtattr->rta_type = tswap16(rtattr->rta_type);
2871
-
ret = target_to_host_rtattr(rtattr);
2872
-
if (ret < 0) {
2873
-
return ret;
2874
-
}
2875
-
len -= RTA_ALIGN(rtattr->rta_len);
2876
-
rtattr = (struct rtattr *)(((char *)rtattr) +
2877
-
RTA_ALIGN(rtattr->rta_len));
2878
-
}
2879
-
return 0;
2880
-
}
2881
-
2882
-
static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr)
2883
-
{
2884
-
switch (rtattr->rta_type) {
2885
-
default:
2886
-
gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr->rta_type);
2887
-
break;
2888
-
}
2889
-
return 0;
2890
-
}
2891
-
2892
-
static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr)
2893
-
{
2894
-
switch (rtattr->rta_type) {
2895
-
/* binary: depends on family type */
2896
-
case IFA_LOCAL:
2897
-
case IFA_ADDRESS:
2898
-
break;
2899
-
default:
2900
-
gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type);
2901
-
break;
2902
-
}
2903
-
return 0;
2904
-
}
2905
-
2906
-
static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr)
2907
-
{
2908
-
uint32_t *u32;
2909
-
switch (rtattr->rta_type) {
2910
-
/* binary: depends on family type */
2911
-
case QEMU_RTA_DST:
2912
-
case QEMU_RTA_SRC:
2913
-
case QEMU_RTA_GATEWAY:
2914
-
break;
2915
-
/* u32 */
2916
-
case QEMU_RTA_PRIORITY:
2917
-
case QEMU_RTA_OIF:
2918
-
u32 = RTA_DATA(rtattr);
2919
-
*u32 = tswap32(*u32);
2920
-
break;
2921
-
default:
2922
-
gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type);
2923
-
break;
2924
-
}
2925
-
return 0;
2926
-
}
2927
-
2928
-
static void target_to_host_link_rtattr(struct rtattr *rtattr,
2929
-
uint32_t rtattr_len)
2930
-
{
2931
-
target_to_host_for_each_rtattr(rtattr, rtattr_len,
2932
-
target_to_host_data_link_rtattr);
2933
-
}
2934
-
2935
-
static void target_to_host_addr_rtattr(struct rtattr *rtattr,
2936
-
uint32_t rtattr_len)
2937
-
{
2938
-
target_to_host_for_each_rtattr(rtattr, rtattr_len,
2939
-
target_to_host_data_addr_rtattr);
2940
-
}
2941
-
2942
-
static void target_to_host_route_rtattr(struct rtattr *rtattr,
2943
-
uint32_t rtattr_len)
2944
-
{
2945
-
target_to_host_for_each_rtattr(rtattr, rtattr_len,
2946
-
target_to_host_data_route_rtattr);
2947
-
}
2948
-
2949
-
static abi_long target_to_host_data_route(struct nlmsghdr *nlh)
2950
-
{
2951
-
struct ifinfomsg *ifi;
2952
-
struct ifaddrmsg *ifa;
2953
-
struct rtmsg *rtm;
2954
-
2955
-
switch (nlh->nlmsg_type) {
2956
-
case RTM_GETLINK:
2957
-
break;
2958
-
case RTM_NEWLINK:
2959
-
case RTM_DELLINK:
2960
-
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
2961
-
ifi = NLMSG_DATA(nlh);
2962
-
ifi->ifi_type = tswap16(ifi->ifi_type);
2963
-
ifi->ifi_index = tswap32(ifi->ifi_index);
2964
-
ifi->ifi_flags = tswap32(ifi->ifi_flags);
2965
-
ifi->ifi_change = tswap32(ifi->ifi_change);
2966
-
target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len -
2967
-
NLMSG_LENGTH(sizeof(*ifi)));
2968
-
}
2969
-
break;
2970
-
case RTM_GETADDR:
2971
-
case RTM_NEWADDR:
2972
-
case RTM_DELADDR:
2973
-
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
2974
-
ifa = NLMSG_DATA(nlh);
2975
-
ifa->ifa_index = tswap32(ifa->ifa_index);
2976
-
target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len -
2977
-
NLMSG_LENGTH(sizeof(*ifa)));
2978
-
}
2979
-
break;
2980
-
case RTM_GETROUTE:
2981
-
break;
2982
-
case RTM_NEWROUTE:
2983
-
case RTM_DELROUTE:
2984
-
if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
2985
-
rtm = NLMSG_DATA(nlh);
2986
-
rtm->rtm_flags = tswap32(rtm->rtm_flags);
2987
-
target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len -
2988
-
NLMSG_LENGTH(sizeof(*rtm)));
2989
-
}
2990
-
break;
2991
-
default:
2992
-
return -TARGET_EOPNOTSUPP;
2993
-
}
2994
-
return 0;
2995
-
}
2996
-
2997
-
static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t len)
2998
-
{
2999
-
return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_route);
3000
-
}
3001
-
#endif /* CONFIG_RTNETLINK */
3002
-
3003
-
static abi_long host_to_target_data_audit(struct nlmsghdr *nlh)
3004
-
{
3005
-
switch (nlh->nlmsg_type) {
3006
-
default:
3007
-
gemu_log("Unknown host audit message type %d\n",
3008
-
nlh->nlmsg_type);
3009
-
return -TARGET_EINVAL;
3010
-
}
3011
-
return 0;
3012
-
}
3013
-
3014
-
static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh,
3015
-
size_t len)
3016
-
{
3017
-
return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_audit);
3018
-
}
3019
-
3020
-
static abi_long target_to_host_data_audit(struct nlmsghdr *nlh)
3021
-
{
3022
-
switch (nlh->nlmsg_type) {
3023
-
case AUDIT_USER:
3024
-
case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG:
3025
-
case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2:
3026
-
break;
3027
-
default:
3028
-
gemu_log("Unknown target audit message type %d\n",
3029
-
nlh->nlmsg_type);
3030
-
return -TARGET_EINVAL;
3031
-
}
3032
-
3033
-
return 0;
3034
-
}
3035
-
3036
-
static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t len)
3037
-
{
3038
-
return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_audit);
3039
-
}
3040
-
3041
1783
/* do_setsockopt() Must return target values and target errnos. */
3042
1784
static abi_long do_setsockopt(int sockfd, int level, int optname,
3043
1785
abi_ulong optval_addr, socklen_t optlen)
···
3732
2474
#endif
3733
2475
return fd;
3734
2476
}
3735
-
3736
-
static abi_long packet_target_to_host_sockaddr(void *host_addr,
3737
-
abi_ulong target_addr,
3738
-
socklen_t len)
3739
-
{
3740
-
struct sockaddr *addr = host_addr;
3741
-
struct target_sockaddr *target_saddr;
3742
-
3743
-
target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
3744
-
if (!target_saddr) {
3745
-
return -TARGET_EFAULT;
3746
-
}
3747
-
3748
-
memcpy(addr, target_saddr, len);
3749
-
addr->sa_family = tswap16(target_saddr->sa_family);
3750
-
/* spkt_protocol is big-endian */
3751
-
3752
-
unlock_user(target_saddr, target_addr, 0);
3753
-
return 0;
3754
-
}
3755
-
3756
-
static TargetFdTrans target_packet_trans = {
3757
-
.target_to_host_addr = packet_target_to_host_sockaddr,
3758
-
};
3759
-
3760
-
#ifdef CONFIG_RTNETLINK
3761
-
static abi_long netlink_route_target_to_host(void *buf, size_t len)
3762
-
{
3763
-
abi_long ret;
3764
-
3765
-
ret = target_to_host_nlmsg_route(buf, len);
3766
-
if (ret < 0) {
3767
-
return ret;
3768
-
}
3769
-
3770
-
return len;
3771
-
}
3772
-
3773
-
static abi_long netlink_route_host_to_target(void *buf, size_t len)
3774
-
{
3775
-
abi_long ret;
3776
-
3777
-
ret = host_to_target_nlmsg_route(buf, len);
3778
-
if (ret < 0) {
3779
-
return ret;
3780
-
}
3781
-
3782
-
return len;
3783
-
}
3784
-
3785
-
static TargetFdTrans target_netlink_route_trans = {
3786
-
.target_to_host_data = netlink_route_target_to_host,
3787
-
.host_to_target_data = netlink_route_host_to_target,
3788
-
};
3789
-
#endif /* CONFIG_RTNETLINK */
3790
-
3791
-
static abi_long netlink_audit_target_to_host(void *buf, size_t len)
3792
-
{
3793
-
abi_long ret;
3794
-
3795
-
ret = target_to_host_nlmsg_audit(buf, len);
3796
-
if (ret < 0) {
3797
-
return ret;
3798
-
}
3799
-
3800
-
return len;
3801
-
}
3802
-
3803
-
static abi_long netlink_audit_host_to_target(void *buf, size_t len)
3804
-
{
3805
-
abi_long ret;
3806
-
3807
-
ret = host_to_target_nlmsg_audit(buf, len);
3808
-
if (ret < 0) {
3809
-
return ret;
3810
-
}
3811
-
3812
-
return len;
3813
-
}
3814
-
3815
-
static TargetFdTrans target_netlink_audit_trans = {
3816
-
.target_to_host_data = netlink_audit_target_to_host,
3817
-
.host_to_target_data = netlink_audit_host_to_target,
3818
-
};
3819
2477
3820
2478
/* do_socket() Must return target values and target errnos. */
3821
2479
static abi_long do_socket(int domain, int type, int protocol)
···
7596
6254
7597
6255
#if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4)
7598
6256
7599
-
/* signalfd siginfo conversion */
7600
-
7601
-
static void
7602
-
host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo,
7603
-
const struct signalfd_siginfo *info)
7604
-
{
7605
-
int sig = host_to_target_signal(info->ssi_signo);
7606
-
7607
-
/* linux/signalfd.h defines a ssi_addr_lsb
7608
-
* not defined in sys/signalfd.h but used by some kernels
7609
-
*/
7610
-
7611
-
#ifdef BUS_MCEERR_AO
7612
-
if (tinfo->ssi_signo == SIGBUS &&
7613
-
(tinfo->ssi_code == BUS_MCEERR_AR ||
7614
-
tinfo->ssi_code == BUS_MCEERR_AO)) {
7615
-
uint16_t *ssi_addr_lsb = (uint16_t *)(&info->ssi_addr + 1);
7616
-
uint16_t *tssi_addr_lsb = (uint16_t *)(&tinfo->ssi_addr + 1);
7617
-
*tssi_addr_lsb = tswap16(*ssi_addr_lsb);
7618
-
}
7619
-
#endif
7620
-
7621
-
tinfo->ssi_signo = tswap32(sig);
7622
-
tinfo->ssi_errno = tswap32(tinfo->ssi_errno);
7623
-
tinfo->ssi_code = tswap32(info->ssi_code);
7624
-
tinfo->ssi_pid = tswap32(info->ssi_pid);
7625
-
tinfo->ssi_uid = tswap32(info->ssi_uid);
7626
-
tinfo->ssi_fd = tswap32(info->ssi_fd);
7627
-
tinfo->ssi_tid = tswap32(info->ssi_tid);
7628
-
tinfo->ssi_band = tswap32(info->ssi_band);
7629
-
tinfo->ssi_overrun = tswap32(info->ssi_overrun);
7630
-
tinfo->ssi_trapno = tswap32(info->ssi_trapno);
7631
-
tinfo->ssi_status = tswap32(info->ssi_status);
7632
-
tinfo->ssi_int = tswap32(info->ssi_int);
7633
-
tinfo->ssi_ptr = tswap64(info->ssi_ptr);
7634
-
tinfo->ssi_utime = tswap64(info->ssi_utime);
7635
-
tinfo->ssi_stime = tswap64(info->ssi_stime);
7636
-
tinfo->ssi_addr = tswap64(info->ssi_addr);
7637
-
}
7638
-
7639
-
static abi_long host_to_target_data_signalfd(void *buf, size_t len)
7640
-
{
7641
-
int i;
7642
-
7643
-
for (i = 0; i < len; i += sizeof(struct signalfd_siginfo)) {
7644
-
host_to_target_signalfd_siginfo(buf + i, buf + i);
7645
-
}
7646
-
7647
-
return len;
7648
-
}
7649
-
7650
-
static TargetFdTrans target_signalfd_trans = {
7651
-
.host_to_target_data = host_to_target_data_signalfd,
7652
-
};
7653
-
7654
6257
static abi_long do_signalfd4(int fd, abi_long mask, int flags)
7655
6258
{
7656
6259
int host_flags;
···
7975
6578
7976
6579
return timerid;
7977
6580
}
7978
-
7979
-
static abi_long swap_data_eventfd(void *buf, size_t len)
7980
-
{
7981
-
uint64_t *counter = buf;
7982
-
int i;
7983
-
7984
-
if (len < sizeof(uint64_t)) {
7985
-
return -EINVAL;
7986
-
}
7987
-
7988
-
for (i = 0; i < len; i += sizeof(uint64_t)) {
7989
-
*counter = tswap64(*counter);
7990
-
counter++;
7991
-
}
7992
-
7993
-
return len;
7994
-
}
7995
-
7996
-
static TargetFdTrans target_eventfd_trans = {
7997
-
.host_to_target_data = swap_data_eventfd,
7998
-
.target_to_host_data = swap_data_eventfd,
7999
-
};
8000
-
8001
-
#if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \
8002
-
(defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \
8003
-
defined(__NR_inotify_init1))
8004
-
static abi_long host_to_target_data_inotify(void *buf, size_t len)
8005
-
{
8006
-
struct inotify_event *ev;
8007
-
int i;
8008
-
uint32_t name_len;
8009
-
8010
-
for (i = 0; i < len; i += sizeof(struct inotify_event) + name_len) {
8011
-
ev = (struct inotify_event *)((char *)buf + i);
8012
-
name_len = ev->len;
8013
-
8014
-
ev->wd = tswap32(ev->wd);
8015
-
ev->mask = tswap32(ev->mask);
8016
-
ev->cookie = tswap32(ev->cookie);
8017
-
ev->len = tswap32(name_len);
8018
-
}
8019
-
8020
-
return len;
8021
-
}
8022
-
8023
-
static TargetFdTrans target_inotify_trans = {
8024
-
.host_to_target_data = host_to_target_data_inotify,
8025
-
};
8026
-
#endif
8027
6581
8028
6582
static int target_to_host_cpu_mask(unsigned long *host_mask,
8029
6583
size_t host_size,