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