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