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