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