From nobody Sat Apr 27 13:34:06 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1537909018038676.7818571898416; Tue, 25 Sep 2018 13:56:58 -0700 (PDT) Received: from localhost ([::1]:55235 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uO8-0002uM-Cp for importer@patchew.org; Tue, 25 Sep 2018 16:56:56 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:53991) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uJv-0000CT-2Q for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:40 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1g4uJp-0002VE-6R for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:35 -0400 Received: from mout.kundenserver.de ([212.227.126.133]:33193) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1g4uJo-0002Te-ID for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:29 -0400 Received: from localhost.localdomain ([78.238.229.36]) by mrelayeu.kundenserver.de (mreue009 [212.227.15.167]) with ESMTPSA (Nemesis) id 1N1fei-1fcGVB3bUe-0122Ke; Tue, 25 Sep 2018 22:51:52 +0200 From: Laurent Vivier To: qemu-devel@nongnu.org Date: Tue, 25 Sep 2018 22:51:25 +0200 Message-Id: <20180925205129.25261-2-laurent@vivier.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180925205129.25261-1-laurent@vivier.eu> References: <20180925205129.25261-1-laurent@vivier.eu> X-Provags-ID: V03:K1:QFSdw3jeXlhKNon23C0C7dWZdL6eqTqxzc7pUTk6rF03aDsp8Ho XXctgTmmi26BUCK1s7LFdQc0az7xRI//LEmZhBUXAQxUhEq+tT+hmZvq5BZiIH4h/4LVBQI OvblDH6M9/4Jkr/ico/KQ6Z8VERhiRQvsuRrNjnT3onr01mo0QmroGo5c2m99ifGF+F7CQQ /rBZz8m/dcGoVtGsDDydQ== X-UI-Out-Filterresults: notjunk:1;V01:K0:pbm0hkWZWfg=:yNJLCrNnyMk8qaHkNazdn5 E1GBCsEVBCYKT6fq/zFaxgqhy2a/V4orn4SY7sLytOku++bp/mPj5Q3ezZUL+njS4UAkKZ8HF fdN+8mNNfLnIbFD4XVEkRL8K3EhiyTOnByGgqFhD+S29VDnVXyICn74rwfRczmOyIQ9k0RN33 pxBiUGeSo/iJER84V53XYUBLu35pon7YW/2vdcXayF/l9CyBpxDrQg8nCY51V+q7SurFkW05Y GXUMEPXKIvq0c4m94fv+yFMf8RiKYhyIKIMyNU5/LNlUOndBEpHsYnVXCoBpv0WgwC455iKWB yW9D7JpHJOdGpC+cHWYkP64O9j9szDYzBPkocewcRNkkDinOfldVeXlY5GvFnthVDoyErhBvl lTNLZGi+Asx86BiWQeYfaeTiTRh082xH6EtVZGrAcawNE7y/ZEaISPJMNZxmcn7zsKgiROvHi Np4lxI+HEEGz/giM86lAt60RxLr0Q9MhwDVF7DMw2JMuIl4xp2Fh8yAaCdU4zHRlumCtUED60 rJSZNLvfp7dI3Hr1zA6DhsZTW3SzgDMwfKVCYge+l7+T5dUzF7VmeIN4hgoqTPCKLoGMIfbSu UWOO57zX0Egg9ZBVAFgb2hSyC9yQCeqAVlt667N1hWt2B7CzGVibnVtIxwo7EO9SBBtTZ8VUC ljpS0sLJamxFf7I59H5/BDpFXoBFcXL3crk3crdf2IWI4YsKBMowj0bf+x9Q0T5TBU5k= X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 212.227.126.133 Subject: [Qemu-devel] [PULL v2 1/5] linux-user: move TargetFdTrans functions to their own file X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Riku Voipio , Laurent Vivier Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" This will ease to move out syscall functions from syscall.c Signed-off-by: Laurent Vivier Reviewed-by: Richard Henderson Message-Id: <20180823222215.13781-1-laurent@vivier.eu> --- linux-user/Makefile.objs | 2 +- linux-user/fd-trans.c | 1409 +++++++++++++++++++++++++++++++++++++ linux-user/fd-trans.h | 97 +++ linux-user/syscall.c | 1448 +------------------------------------- 4 files changed, 1508 insertions(+), 1448 deletions(-) create mode 100644 linux-user/fd-trans.c create mode 100644 linux-user/fd-trans.h diff --git a/linux-user/Makefile.objs b/linux-user/Makefile.objs index b5dfb71f25..769b8d8336 100644 --- a/linux-user/Makefile.objs +++ b/linux-user/Makefile.objs @@ -1,7 +1,7 @@ obj-y =3D main.o syscall.o strace.o mmap.o signal.o \ elfload.o linuxload.o uaccess.o uname.o \ safe-syscall.o $(TARGET_ABI_DIR)/signal.o \ - $(TARGET_ABI_DIR)/cpu_loop.o exit.o + $(TARGET_ABI_DIR)/cpu_loop.o exit.o fd-trans.o =20 obj-$(TARGET_HAS_BFLT) +=3D flatload.o obj-$(TARGET_I386) +=3D vm86.o diff --git a/linux-user/fd-trans.c b/linux-user/fd-trans.c new file mode 100644 index 0000000000..216b9f0614 --- /dev/null +++ b/linux-user/fd-trans.c @@ -0,0 +1,1409 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "qemu/osdep.h" + +#include +#include +#include +#ifdef CONFIG_INOTIFY +#include +#endif +#include +#ifdef CONFIG_RTNETLINK +#include +#include +#endif +#include "qemu.h" +#include "fd-trans.h" + +enum { + QEMU_IFLA_BR_UNSPEC, + QEMU_IFLA_BR_FORWARD_DELAY, + QEMU_IFLA_BR_HELLO_TIME, + QEMU_IFLA_BR_MAX_AGE, + QEMU_IFLA_BR_AGEING_TIME, + QEMU_IFLA_BR_STP_STATE, + QEMU_IFLA_BR_PRIORITY, + QEMU_IFLA_BR_VLAN_FILTERING, + QEMU_IFLA_BR_VLAN_PROTOCOL, + QEMU_IFLA_BR_GROUP_FWD_MASK, + QEMU_IFLA_BR_ROOT_ID, + QEMU_IFLA_BR_BRIDGE_ID, + QEMU_IFLA_BR_ROOT_PORT, + QEMU_IFLA_BR_ROOT_PATH_COST, + QEMU_IFLA_BR_TOPOLOGY_CHANGE, + QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED, + QEMU_IFLA_BR_HELLO_TIMER, + QEMU_IFLA_BR_TCN_TIMER, + QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER, + QEMU_IFLA_BR_GC_TIMER, + QEMU_IFLA_BR_GROUP_ADDR, + QEMU_IFLA_BR_FDB_FLUSH, + QEMU_IFLA_BR_MCAST_ROUTER, + QEMU_IFLA_BR_MCAST_SNOOPING, + QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR, + QEMU_IFLA_BR_MCAST_QUERIER, + QEMU_IFLA_BR_MCAST_HASH_ELASTICITY, + QEMU_IFLA_BR_MCAST_HASH_MAX, + QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT, + QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT, + QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL, + QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL, + QEMU_IFLA_BR_MCAST_QUERIER_INTVL, + QEMU_IFLA_BR_MCAST_QUERY_INTVL, + QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL, + QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL, + QEMU_IFLA_BR_NF_CALL_IPTABLES, + QEMU_IFLA_BR_NF_CALL_IP6TABLES, + QEMU_IFLA_BR_NF_CALL_ARPTABLES, + QEMU_IFLA_BR_VLAN_DEFAULT_PVID, + QEMU_IFLA_BR_PAD, + QEMU_IFLA_BR_VLAN_STATS_ENABLED, + QEMU_IFLA_BR_MCAST_STATS_ENABLED, + QEMU_IFLA_BR_MCAST_IGMP_VERSION, + QEMU_IFLA_BR_MCAST_MLD_VERSION, + QEMU___IFLA_BR_MAX, +}; + +enum { + QEMU_IFLA_UNSPEC, + QEMU_IFLA_ADDRESS, + QEMU_IFLA_BROADCAST, + QEMU_IFLA_IFNAME, + QEMU_IFLA_MTU, + QEMU_IFLA_LINK, + QEMU_IFLA_QDISC, + QEMU_IFLA_STATS, + QEMU_IFLA_COST, + QEMU_IFLA_PRIORITY, + QEMU_IFLA_MASTER, + QEMU_IFLA_WIRELESS, + QEMU_IFLA_PROTINFO, + QEMU_IFLA_TXQLEN, + QEMU_IFLA_MAP, + QEMU_IFLA_WEIGHT, + QEMU_IFLA_OPERSTATE, + QEMU_IFLA_LINKMODE, + QEMU_IFLA_LINKINFO, + QEMU_IFLA_NET_NS_PID, + QEMU_IFLA_IFALIAS, + QEMU_IFLA_NUM_VF, + QEMU_IFLA_VFINFO_LIST, + QEMU_IFLA_STATS64, + QEMU_IFLA_VF_PORTS, + QEMU_IFLA_PORT_SELF, + QEMU_IFLA_AF_SPEC, + QEMU_IFLA_GROUP, + QEMU_IFLA_NET_NS_FD, + QEMU_IFLA_EXT_MASK, + QEMU_IFLA_PROMISCUITY, + QEMU_IFLA_NUM_TX_QUEUES, + QEMU_IFLA_NUM_RX_QUEUES, + QEMU_IFLA_CARRIER, + QEMU_IFLA_PHYS_PORT_ID, + QEMU_IFLA_CARRIER_CHANGES, + QEMU_IFLA_PHYS_SWITCH_ID, + QEMU_IFLA_LINK_NETNSID, + QEMU_IFLA_PHYS_PORT_NAME, + QEMU_IFLA_PROTO_DOWN, + QEMU_IFLA_GSO_MAX_SEGS, + QEMU_IFLA_GSO_MAX_SIZE, + QEMU_IFLA_PAD, + QEMU_IFLA_XDP, + QEMU_IFLA_EVENT, + QEMU_IFLA_NEW_NETNSID, + QEMU_IFLA_IF_NETNSID, + QEMU_IFLA_CARRIER_UP_COUNT, + QEMU_IFLA_CARRIER_DOWN_COUNT, + QEMU_IFLA_NEW_IFINDEX, + QEMU___IFLA_MAX +}; + +enum { + QEMU_IFLA_BRPORT_UNSPEC, + QEMU_IFLA_BRPORT_STATE, + QEMU_IFLA_BRPORT_PRIORITY, + QEMU_IFLA_BRPORT_COST, + QEMU_IFLA_BRPORT_MODE, + QEMU_IFLA_BRPORT_GUARD, + QEMU_IFLA_BRPORT_PROTECT, + QEMU_IFLA_BRPORT_FAST_LEAVE, + QEMU_IFLA_BRPORT_LEARNING, + QEMU_IFLA_BRPORT_UNICAST_FLOOD, + QEMU_IFLA_BRPORT_PROXYARP, + QEMU_IFLA_BRPORT_LEARNING_SYNC, + QEMU_IFLA_BRPORT_PROXYARP_WIFI, + QEMU_IFLA_BRPORT_ROOT_ID, + QEMU_IFLA_BRPORT_BRIDGE_ID, + QEMU_IFLA_BRPORT_DESIGNATED_PORT, + QEMU_IFLA_BRPORT_DESIGNATED_COST, + QEMU_IFLA_BRPORT_ID, + QEMU_IFLA_BRPORT_NO, + QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK, + QEMU_IFLA_BRPORT_CONFIG_PENDING, + QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER, + QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER, + QEMU_IFLA_BRPORT_HOLD_TIMER, + QEMU_IFLA_BRPORT_FLUSH, + QEMU_IFLA_BRPORT_MULTICAST_ROUTER, + QEMU_IFLA_BRPORT_PAD, + QEMU_IFLA_BRPORT_MCAST_FLOOD, + QEMU_IFLA_BRPORT_MCAST_TO_UCAST, + QEMU_IFLA_BRPORT_VLAN_TUNNEL, + QEMU_IFLA_BRPORT_BCAST_FLOOD, + QEMU_IFLA_BRPORT_GROUP_FWD_MASK, + QEMU_IFLA_BRPORT_NEIGH_SUPPRESS, + QEMU___IFLA_BRPORT_MAX +}; + +enum { + QEMU_IFLA_TUN_UNSPEC, + QEMU_IFLA_TUN_OWNER, + QEMU_IFLA_TUN_GROUP, + QEMU_IFLA_TUN_TYPE, + QEMU_IFLA_TUN_PI, + QEMU_IFLA_TUN_VNET_HDR, + QEMU_IFLA_TUN_PERSIST, + QEMU_IFLA_TUN_MULTI_QUEUE, + QEMU_IFLA_TUN_NUM_QUEUES, + QEMU_IFLA_TUN_NUM_DISABLED_QUEUES, + QEMU___IFLA_TUN_MAX, +}; + +enum { + QEMU_IFLA_INFO_UNSPEC, + QEMU_IFLA_INFO_KIND, + QEMU_IFLA_INFO_DATA, + QEMU_IFLA_INFO_XSTATS, + QEMU_IFLA_INFO_SLAVE_KIND, + QEMU_IFLA_INFO_SLAVE_DATA, + QEMU___IFLA_INFO_MAX, +}; + +enum { + QEMU_IFLA_INET_UNSPEC, + QEMU_IFLA_INET_CONF, + QEMU___IFLA_INET_MAX, +}; + +enum { + QEMU_IFLA_INET6_UNSPEC, + QEMU_IFLA_INET6_FLAGS, + QEMU_IFLA_INET6_CONF, + QEMU_IFLA_INET6_STATS, + QEMU_IFLA_INET6_MCAST, + QEMU_IFLA_INET6_CACHEINFO, + QEMU_IFLA_INET6_ICMP6STATS, + QEMU_IFLA_INET6_TOKEN, + QEMU_IFLA_INET6_ADDR_GEN_MODE, + QEMU___IFLA_INET6_MAX +}; + +enum { + QEMU_IFLA_XDP_UNSPEC, + QEMU_IFLA_XDP_FD, + QEMU_IFLA_XDP_ATTACHED, + QEMU_IFLA_XDP_FLAGS, + QEMU_IFLA_XDP_PROG_ID, + QEMU___IFLA_XDP_MAX, +}; + +enum { + QEMU_RTA_UNSPEC, + QEMU_RTA_DST, + QEMU_RTA_SRC, + QEMU_RTA_IIF, + QEMU_RTA_OIF, + QEMU_RTA_GATEWAY, + QEMU_RTA_PRIORITY, + QEMU_RTA_PREFSRC, + QEMU_RTA_METRICS, + QEMU_RTA_MULTIPATH, + QEMU_RTA_PROTOINFO, /* no longer used */ + QEMU_RTA_FLOW, + QEMU_RTA_CACHEINFO, + QEMU_RTA_SESSION, /* no longer used */ + QEMU_RTA_MP_ALGO, /* no longer used */ + QEMU_RTA_TABLE, + QEMU_RTA_MARK, + QEMU_RTA_MFC_STATS, + QEMU_RTA_VIA, + QEMU_RTA_NEWDST, + QEMU_RTA_PREF, + QEMU_RTA_ENCAP_TYPE, + QEMU_RTA_ENCAP, + QEMU_RTA_EXPIRES, + QEMU_RTA_PAD, + QEMU_RTA_UID, + QEMU_RTA_TTL_PROPAGATE, + QEMU_RTA_IP_PROTO, + QEMU_RTA_SPORT, + QEMU_RTA_DPORT, + QEMU___RTA_MAX +}; + +TargetFdTrans **target_fd_trans; +unsigned int target_fd_max; + +static void tswap_nlmsghdr(struct nlmsghdr *nlh) +{ + nlh->nlmsg_len =3D tswap32(nlh->nlmsg_len); + nlh->nlmsg_type =3D tswap16(nlh->nlmsg_type); + nlh->nlmsg_flags =3D tswap16(nlh->nlmsg_flags); + nlh->nlmsg_seq =3D tswap32(nlh->nlmsg_seq); + nlh->nlmsg_pid =3D tswap32(nlh->nlmsg_pid); +} + +static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh, + size_t len, + abi_long (*host_to_target_nl= msg) + (struct nlmsghdr *)) +{ + uint32_t nlmsg_len; + abi_long ret; + + while (len > sizeof(struct nlmsghdr)) { + + nlmsg_len =3D nlh->nlmsg_len; + if (nlmsg_len < sizeof(struct nlmsghdr) || + nlmsg_len > len) { + break; + } + + switch (nlh->nlmsg_type) { + case NLMSG_DONE: + tswap_nlmsghdr(nlh); + return 0; + case NLMSG_NOOP: + break; + case NLMSG_ERROR: + { + struct nlmsgerr *e =3D NLMSG_DATA(nlh); + e->error =3D tswap32(e->error); + tswap_nlmsghdr(&e->msg); + tswap_nlmsghdr(nlh); + return 0; + } + default: + ret =3D host_to_target_nlmsg(nlh); + if (ret < 0) { + tswap_nlmsghdr(nlh); + return ret; + } + break; + } + tswap_nlmsghdr(nlh); + len -=3D NLMSG_ALIGN(nlmsg_len); + nlh =3D (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len)); + } + return 0; +} + +static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh, + size_t len, + abi_long (*target_to_host_nl= msg) + (struct nlmsghdr *)) +{ + int ret; + + while (len > sizeof(struct nlmsghdr)) { + if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) || + tswap32(nlh->nlmsg_len) > len) { + break; + } + tswap_nlmsghdr(nlh); + switch (nlh->nlmsg_type) { + case NLMSG_DONE: + return 0; + case NLMSG_NOOP: + break; + case NLMSG_ERROR: + { + struct nlmsgerr *e =3D NLMSG_DATA(nlh); + e->error =3D tswap32(e->error); + tswap_nlmsghdr(&e->msg); + return 0; + } + default: + ret =3D target_to_host_nlmsg(nlh); + if (ret < 0) { + return ret; + } + } + len -=3D NLMSG_ALIGN(nlh->nlmsg_len); + nlh =3D (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg= _len)); + } + return 0; +} + +#ifdef CONFIG_RTNETLINK +static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr, + size_t len, void *context, + abi_long (*host_to_target_n= lattr) + (struct nlattr *, + void *context)) +{ + unsigned short nla_len; + abi_long ret; + + while (len > sizeof(struct nlattr)) { + nla_len =3D nlattr->nla_len; + if (nla_len < sizeof(struct nlattr) || + nla_len > len) { + break; + } + ret =3D host_to_target_nlattr(nlattr, context); + nlattr->nla_len =3D tswap16(nlattr->nla_len); + nlattr->nla_type =3D tswap16(nlattr->nla_type); + if (ret < 0) { + return ret; + } + len -=3D NLA_ALIGN(nla_len); + nlattr =3D (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len)= ); + } + return 0; +} + +static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr, + size_t len, + abi_long (*host_to_target_r= tattr) + (struct rtattr *)) +{ + unsigned short rta_len; + abi_long ret; + + while (len > sizeof(struct rtattr)) { + rta_len =3D rtattr->rta_len; + if (rta_len < sizeof(struct rtattr) || + rta_len > len) { + break; + } + ret =3D host_to_target_rtattr(rtattr); + rtattr->rta_len =3D tswap16(rtattr->rta_len); + rtattr->rta_type =3D tswap16(rtattr->rta_type); + if (ret < 0) { + return ret; + } + len -=3D RTA_ALIGN(rta_len); + rtattr =3D (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len)= ); + } + return 0; +} + +#define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN) + +static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr, + void *context) +{ + uint16_t *u16; + uint32_t *u32; + uint64_t *u64; + + switch (nlattr->nla_type) { + /* no data */ + case QEMU_IFLA_BR_FDB_FLUSH: + break; + /* binary */ + case QEMU_IFLA_BR_GROUP_ADDR: + break; + /* uint8_t */ + case QEMU_IFLA_BR_VLAN_FILTERING: + case QEMU_IFLA_BR_TOPOLOGY_CHANGE: + case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED: + case QEMU_IFLA_BR_MCAST_ROUTER: + case QEMU_IFLA_BR_MCAST_SNOOPING: + case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR: + case QEMU_IFLA_BR_MCAST_QUERIER: + case QEMU_IFLA_BR_NF_CALL_IPTABLES: + case QEMU_IFLA_BR_NF_CALL_IP6TABLES: + case QEMU_IFLA_BR_NF_CALL_ARPTABLES: + case QEMU_IFLA_BR_VLAN_STATS_ENABLED: + case QEMU_IFLA_BR_MCAST_STATS_ENABLED: + case QEMU_IFLA_BR_MCAST_IGMP_VERSION: + case QEMU_IFLA_BR_MCAST_MLD_VERSION: + break; + /* uint16_t */ + case QEMU_IFLA_BR_PRIORITY: + case QEMU_IFLA_BR_VLAN_PROTOCOL: + case QEMU_IFLA_BR_GROUP_FWD_MASK: + case QEMU_IFLA_BR_ROOT_PORT: + case QEMU_IFLA_BR_VLAN_DEFAULT_PVID: + u16 =3D NLA_DATA(nlattr); + *u16 =3D tswap16(*u16); + break; + /* uint32_t */ + case QEMU_IFLA_BR_FORWARD_DELAY: + case QEMU_IFLA_BR_HELLO_TIME: + case QEMU_IFLA_BR_MAX_AGE: + case QEMU_IFLA_BR_AGEING_TIME: + case QEMU_IFLA_BR_STP_STATE: + case QEMU_IFLA_BR_ROOT_PATH_COST: + case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY: + case QEMU_IFLA_BR_MCAST_HASH_MAX: + case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT: + case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT: + u32 =3D NLA_DATA(nlattr); + *u32 =3D tswap32(*u32); + break; + /* uint64_t */ + case QEMU_IFLA_BR_HELLO_TIMER: + case QEMU_IFLA_BR_TCN_TIMER: + case QEMU_IFLA_BR_GC_TIMER: + case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER: + case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL: + case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL: + case QEMU_IFLA_BR_MCAST_QUERIER_INTVL: + case QEMU_IFLA_BR_MCAST_QUERY_INTVL: + case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL: + case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL: + u64 =3D NLA_DATA(nlattr); + *u64 =3D tswap64(*u64); + break; + /* ifla_bridge_id: uin8_t[] */ + case QEMU_IFLA_BR_ROOT_ID: + case QEMU_IFLA_BR_BRIDGE_ID: + break; + default: + gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr->nla_type); + break; + } + return 0; +} + +static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nla= ttr, + void *context) +{ + uint16_t *u16; + uint32_t *u32; + uint64_t *u64; + + switch (nlattr->nla_type) { + /* uint8_t */ + case QEMU_IFLA_BRPORT_STATE: + case QEMU_IFLA_BRPORT_MODE: + case QEMU_IFLA_BRPORT_GUARD: + case QEMU_IFLA_BRPORT_PROTECT: + case QEMU_IFLA_BRPORT_FAST_LEAVE: + case QEMU_IFLA_BRPORT_LEARNING: + case QEMU_IFLA_BRPORT_UNICAST_FLOOD: + case QEMU_IFLA_BRPORT_PROXYARP: + case QEMU_IFLA_BRPORT_LEARNING_SYNC: + case QEMU_IFLA_BRPORT_PROXYARP_WIFI: + case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK: + case QEMU_IFLA_BRPORT_CONFIG_PENDING: + case QEMU_IFLA_BRPORT_MULTICAST_ROUTER: + case QEMU_IFLA_BRPORT_MCAST_FLOOD: + case QEMU_IFLA_BRPORT_MCAST_TO_UCAST: + case QEMU_IFLA_BRPORT_VLAN_TUNNEL: + case QEMU_IFLA_BRPORT_BCAST_FLOOD: + case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS: + break; + /* uint16_t */ + case QEMU_IFLA_BRPORT_PRIORITY: + case QEMU_IFLA_BRPORT_DESIGNATED_PORT: + case QEMU_IFLA_BRPORT_DESIGNATED_COST: + case QEMU_IFLA_BRPORT_ID: + case QEMU_IFLA_BRPORT_NO: + case QEMU_IFLA_BRPORT_GROUP_FWD_MASK: + u16 =3D NLA_DATA(nlattr); + *u16 =3D tswap16(*u16); + break; + /* uin32_t */ + case QEMU_IFLA_BRPORT_COST: + u32 =3D NLA_DATA(nlattr); + *u32 =3D tswap32(*u32); + break; + /* uint64_t */ + case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER: + case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER: + case QEMU_IFLA_BRPORT_HOLD_TIMER: + u64 =3D NLA_DATA(nlattr); + *u64 =3D tswap64(*u64); + break; + /* ifla_bridge_id: uint8_t[] */ + case QEMU_IFLA_BRPORT_ROOT_ID: + case QEMU_IFLA_BRPORT_BRIDGE_ID: + break; + default: + gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr->nla_type); + break; + } + return 0; +} + +static abi_long host_to_target_data_tun_nlattr(struct nlattr *nlattr, + void *context) +{ + uint32_t *u32; + + switch (nlattr->nla_type) { + /* uint8_t */ + case QEMU_IFLA_TUN_TYPE: + case QEMU_IFLA_TUN_PI: + case QEMU_IFLA_TUN_VNET_HDR: + case QEMU_IFLA_TUN_PERSIST: + case QEMU_IFLA_TUN_MULTI_QUEUE: + break; + /* uint32_t */ + case QEMU_IFLA_TUN_NUM_QUEUES: + case QEMU_IFLA_TUN_NUM_DISABLED_QUEUES: + case QEMU_IFLA_TUN_OWNER: + case QEMU_IFLA_TUN_GROUP: + u32 =3D NLA_DATA(nlattr); + *u32 =3D tswap32(*u32); + break; + default: + gemu_log("Unknown QEMU_IFLA_TUN type %d\n", nlattr->nla_type); + break; + } + return 0; +} + +struct linkinfo_context { + int len; + char *name; + int slave_len; + char *slave_name; +}; + +static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr, + void *context) +{ + struct linkinfo_context *li_context =3D context; + + switch (nlattr->nla_type) { + /* string */ + case QEMU_IFLA_INFO_KIND: + li_context->name =3D NLA_DATA(nlattr); + li_context->len =3D nlattr->nla_len - NLA_HDRLEN; + break; + case QEMU_IFLA_INFO_SLAVE_KIND: + li_context->slave_name =3D NLA_DATA(nlattr); + li_context->slave_len =3D nlattr->nla_len - NLA_HDRLEN; + break; + /* stats */ + case QEMU_IFLA_INFO_XSTATS: + /* FIXME: only used by CAN */ + break; + /* nested */ + case QEMU_IFLA_INFO_DATA: + if (strncmp(li_context->name, "bridge", + li_context->len) =3D=3D 0) { + return host_to_target_for_each_nlattr(NLA_DATA(nlattr), + nlattr->nla_len, + NULL, + host_to_target_data_bridge_nl= attr); + } else if (strncmp(li_context->name, "tun", + li_context->len) =3D=3D 0) { + return host_to_target_for_each_nlattr(NLA_DATA(nlattr), + nlattr->nla_len, + NULL, + host_to_target_data_tun_nl= attr); + } else { + gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context->name); + } + break; + case QEMU_IFLA_INFO_SLAVE_DATA: + if (strncmp(li_context->slave_name, "bridge", + li_context->slave_len) =3D=3D 0) { + return host_to_target_for_each_nlattr(NLA_DATA(nlattr), + nlattr->nla_len, + NULL, + host_to_target_slave_data_bridge_nl= attr); + } else { + gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n", + li_context->slave_name); + } + break; + default: + gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr->nla_typ= e); + break; + } + + return 0; +} + +static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr, + void *context) +{ + uint32_t *u32; + int i; + + switch (nlattr->nla_type) { + case QEMU_IFLA_INET_CONF: + u32 =3D NLA_DATA(nlattr); + for (i =3D 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32); + i++) { + u32[i] =3D tswap32(u32[i]); + } + break; + default: + gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type); + } + return 0; +} + +static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr, + void *context) +{ + uint32_t *u32; + uint64_t *u64; + struct ifla_cacheinfo *ci; + int i; + + switch (nlattr->nla_type) { + /* binaries */ + case QEMU_IFLA_INET6_TOKEN: + break; + /* uint8_t */ + case QEMU_IFLA_INET6_ADDR_GEN_MODE: + break; + /* uint32_t */ + case QEMU_IFLA_INET6_FLAGS: + u32 =3D NLA_DATA(nlattr); + *u32 =3D tswap32(*u32); + break; + /* uint32_t[] */ + case QEMU_IFLA_INET6_CONF: + u32 =3D NLA_DATA(nlattr); + for (i =3D 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32); + i++) { + u32[i] =3D tswap32(u32[i]); + } + break; + /* ifla_cacheinfo */ + case QEMU_IFLA_INET6_CACHEINFO: + ci =3D NLA_DATA(nlattr); + ci->max_reasm_len =3D tswap32(ci->max_reasm_len); + ci->tstamp =3D tswap32(ci->tstamp); + ci->reachable_time =3D tswap32(ci->reachable_time); + ci->retrans_time =3D tswap32(ci->retrans_time); + break; + /* uint64_t[] */ + case QEMU_IFLA_INET6_STATS: + case QEMU_IFLA_INET6_ICMP6STATS: + u64 =3D NLA_DATA(nlattr); + for (i =3D 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64); + i++) { + u64[i] =3D tswap64(u64[i]); + } + break; + default: + gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type); + } + return 0; +} + +static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr, + void *context) +{ + switch (nlattr->nla_type) { + case AF_INET: + return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nl= a_len, + NULL, + host_to_target_data_inet_nlat= tr); + case AF_INET6: + return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nl= a_len, + NULL, + host_to_target_data_inet6_nla= ttr); + default: + gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type); + break; + } + return 0; +} + +static abi_long host_to_target_data_xdp_nlattr(struct nlattr *nlattr, + void *context) +{ + uint32_t *u32; + + switch (nlattr->nla_type) { + /* uint8_t */ + case QEMU_IFLA_XDP_ATTACHED: + break; + /* uint32_t */ + case QEMU_IFLA_XDP_PROG_ID: + u32 =3D NLA_DATA(nlattr); + *u32 =3D tswap32(*u32); + break; + default: + gemu_log("Unknown host XDP type: %d\n", nlattr->nla_type); + break; + } + return 0; +} + +static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr) +{ + uint32_t *u32; + struct rtnl_link_stats *st; + struct rtnl_link_stats64 *st64; + struct rtnl_link_ifmap *map; + struct linkinfo_context li_context; + + switch (rtattr->rta_type) { + /* binary stream */ + case QEMU_IFLA_ADDRESS: + case QEMU_IFLA_BROADCAST: + /* string */ + case QEMU_IFLA_IFNAME: + case QEMU_IFLA_QDISC: + break; + /* uin8_t */ + case QEMU_IFLA_OPERSTATE: + case QEMU_IFLA_LINKMODE: + case QEMU_IFLA_CARRIER: + case QEMU_IFLA_PROTO_DOWN: + break; + /* uint32_t */ + case QEMU_IFLA_MTU: + case QEMU_IFLA_LINK: + case QEMU_IFLA_WEIGHT: + case QEMU_IFLA_TXQLEN: + case QEMU_IFLA_CARRIER_CHANGES: + case QEMU_IFLA_NUM_RX_QUEUES: + case QEMU_IFLA_NUM_TX_QUEUES: + case QEMU_IFLA_PROMISCUITY: + case QEMU_IFLA_EXT_MASK: + case QEMU_IFLA_LINK_NETNSID: + case QEMU_IFLA_GROUP: + case QEMU_IFLA_MASTER: + case QEMU_IFLA_NUM_VF: + case QEMU_IFLA_GSO_MAX_SEGS: + case QEMU_IFLA_GSO_MAX_SIZE: + case QEMU_IFLA_CARRIER_UP_COUNT: + case QEMU_IFLA_CARRIER_DOWN_COUNT: + u32 =3D RTA_DATA(rtattr); + *u32 =3D tswap32(*u32); + break; + /* struct rtnl_link_stats */ + case QEMU_IFLA_STATS: + st =3D RTA_DATA(rtattr); + st->rx_packets =3D tswap32(st->rx_packets); + st->tx_packets =3D tswap32(st->tx_packets); + st->rx_bytes =3D tswap32(st->rx_bytes); + st->tx_bytes =3D tswap32(st->tx_bytes); + st->rx_errors =3D tswap32(st->rx_errors); + st->tx_errors =3D tswap32(st->tx_errors); + st->rx_dropped =3D tswap32(st->rx_dropped); + st->tx_dropped =3D tswap32(st->tx_dropped); + st->multicast =3D tswap32(st->multicast); + st->collisions =3D tswap32(st->collisions); + + /* detailed rx_errors: */ + st->rx_length_errors =3D tswap32(st->rx_length_errors); + st->rx_over_errors =3D tswap32(st->rx_over_errors); + st->rx_crc_errors =3D tswap32(st->rx_crc_errors); + st->rx_frame_errors =3D tswap32(st->rx_frame_errors); + st->rx_fifo_errors =3D tswap32(st->rx_fifo_errors); + st->rx_missed_errors =3D tswap32(st->rx_missed_errors); + + /* detailed tx_errors */ + st->tx_aborted_errors =3D tswap32(st->tx_aborted_errors); + st->tx_carrier_errors =3D tswap32(st->tx_carrier_errors); + st->tx_fifo_errors =3D tswap32(st->tx_fifo_errors); + st->tx_heartbeat_errors =3D tswap32(st->tx_heartbeat_errors); + st->tx_window_errors =3D tswap32(st->tx_window_errors); + + /* for cslip etc */ + st->rx_compressed =3D tswap32(st->rx_compressed); + st->tx_compressed =3D tswap32(st->tx_compressed); + break; + /* struct rtnl_link_stats64 */ + case QEMU_IFLA_STATS64: + st64 =3D RTA_DATA(rtattr); + st64->rx_packets =3D tswap64(st64->rx_packets); + st64->tx_packets =3D tswap64(st64->tx_packets); + st64->rx_bytes =3D tswap64(st64->rx_bytes); + st64->tx_bytes =3D tswap64(st64->tx_bytes); + st64->rx_errors =3D tswap64(st64->rx_errors); + st64->tx_errors =3D tswap64(st64->tx_errors); + st64->rx_dropped =3D tswap64(st64->rx_dropped); + st64->tx_dropped =3D tswap64(st64->tx_dropped); + st64->multicast =3D tswap64(st64->multicast); + st64->collisions =3D tswap64(st64->collisions); + + /* detailed rx_errors: */ + st64->rx_length_errors =3D tswap64(st64->rx_length_errors); + st64->rx_over_errors =3D tswap64(st64->rx_over_errors); + st64->rx_crc_errors =3D tswap64(st64->rx_crc_errors); + st64->rx_frame_errors =3D tswap64(st64->rx_frame_errors); + st64->rx_fifo_errors =3D tswap64(st64->rx_fifo_errors); + st64->rx_missed_errors =3D tswap64(st64->rx_missed_errors); + + /* detailed tx_errors */ + st64->tx_aborted_errors =3D tswap64(st64->tx_aborted_errors); + st64->tx_carrier_errors =3D tswap64(st64->tx_carrier_errors); + st64->tx_fifo_errors =3D tswap64(st64->tx_fifo_errors); + st64->tx_heartbeat_errors =3D tswap64(st64->tx_heartbeat_errors); + st64->tx_window_errors =3D tswap64(st64->tx_window_errors); + + /* for cslip etc */ + st64->rx_compressed =3D tswap64(st64->rx_compressed); + st64->tx_compressed =3D tswap64(st64->tx_compressed); + break; + /* struct rtnl_link_ifmap */ + case QEMU_IFLA_MAP: + map =3D RTA_DATA(rtattr); + map->mem_start =3D tswap64(map->mem_start); + map->mem_end =3D tswap64(map->mem_end); + map->base_addr =3D tswap64(map->base_addr); + map->irq =3D tswap16(map->irq); + break; + /* nested */ + case QEMU_IFLA_LINKINFO: + memset(&li_context, 0, sizeof(li_context)); + return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rt= a_len, + &li_context, + host_to_target_data_linkinfo_nl= attr); + case QEMU_IFLA_AF_SPEC: + return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rt= a_len, + NULL, + host_to_target_data_spec_nlat= tr); + case QEMU_IFLA_XDP: + return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rt= a_len, + NULL, + host_to_target_data_xdp_nl= attr); + default: + gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr->rta_type); + break; + } + return 0; +} + +static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr) +{ + uint32_t *u32; + struct ifa_cacheinfo *ci; + + switch (rtattr->rta_type) { + /* binary: depends on family type */ + case IFA_ADDRESS: + case IFA_LOCAL: + break; + /* string */ + case IFA_LABEL: + break; + /* u32 */ + case IFA_FLAGS: + case IFA_BROADCAST: + u32 =3D RTA_DATA(rtattr); + *u32 =3D tswap32(*u32); + break; + /* struct ifa_cacheinfo */ + case IFA_CACHEINFO: + ci =3D RTA_DATA(rtattr); + ci->ifa_prefered =3D tswap32(ci->ifa_prefered); + ci->ifa_valid =3D tswap32(ci->ifa_valid); + ci->cstamp =3D tswap32(ci->cstamp); + ci->tstamp =3D tswap32(ci->tstamp); + break; + default: + gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type); + break; + } + return 0; +} + +static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr) +{ + uint32_t *u32; + struct rta_cacheinfo *ci; + + switch (rtattr->rta_type) { + /* binary: depends on family type */ + case QEMU_RTA_GATEWAY: + case QEMU_RTA_DST: + case QEMU_RTA_PREFSRC: + break; + /* u8 */ + case QEMU_RTA_PREF: + break; + /* u32 */ + case QEMU_RTA_PRIORITY: + case QEMU_RTA_TABLE: + case QEMU_RTA_OIF: + u32 =3D RTA_DATA(rtattr); + *u32 =3D tswap32(*u32); + break; + /* struct rta_cacheinfo */ + case QEMU_RTA_CACHEINFO: + ci =3D RTA_DATA(rtattr); + ci->rta_clntref =3D tswap32(ci->rta_clntref); + ci->rta_lastuse =3D tswap32(ci->rta_lastuse); + ci->rta_expires =3D tswap32(ci->rta_expires); + ci->rta_error =3D tswap32(ci->rta_error); + ci->rta_used =3D tswap32(ci->rta_used); +#if defined(RTNETLINK_HAVE_PEERINFO) + ci->rta_id =3D tswap32(ci->rta_id); + ci->rta_ts =3D tswap32(ci->rta_ts); + ci->rta_tsage =3D tswap32(ci->rta_tsage); +#endif + break; + default: + gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type); + break; + } + return 0; +} + +static abi_long host_to_target_link_rtattr(struct rtattr *rtattr, + uint32_t rtattr_len) +{ + return host_to_target_for_each_rtattr(rtattr, rtattr_len, + host_to_target_data_link_rtattr); +} + +static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr, + uint32_t rtattr_len) +{ + return host_to_target_for_each_rtattr(rtattr, rtattr_len, + host_to_target_data_addr_rtattr); +} + +static abi_long host_to_target_route_rtattr(struct rtattr *rtattr, + uint32_t rtattr_len) +{ + return host_to_target_for_each_rtattr(rtattr, rtattr_len, + host_to_target_data_route_rtattr= ); +} + +static abi_long host_to_target_data_route(struct nlmsghdr *nlh) +{ + uint32_t nlmsg_len; + struct ifinfomsg *ifi; + struct ifaddrmsg *ifa; + struct rtmsg *rtm; + + nlmsg_len =3D nlh->nlmsg_len; + switch (nlh->nlmsg_type) { + case RTM_NEWLINK: + case RTM_DELLINK: + case RTM_GETLINK: + if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*ifi))) { + ifi =3D NLMSG_DATA(nlh); + ifi->ifi_type =3D tswap16(ifi->ifi_type); + ifi->ifi_index =3D tswap32(ifi->ifi_index); + ifi->ifi_flags =3D tswap32(ifi->ifi_flags); + ifi->ifi_change =3D tswap32(ifi->ifi_change); + host_to_target_link_rtattr(IFLA_RTA(ifi), + nlmsg_len - NLMSG_LENGTH(sizeof(*if= i))); + } + break; + case RTM_NEWADDR: + case RTM_DELADDR: + case RTM_GETADDR: + if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*ifa))) { + ifa =3D NLMSG_DATA(nlh); + ifa->ifa_index =3D tswap32(ifa->ifa_index); + host_to_target_addr_rtattr(IFA_RTA(ifa), + nlmsg_len - NLMSG_LENGTH(sizeof(*if= a))); + } + break; + case RTM_NEWROUTE: + case RTM_DELROUTE: + case RTM_GETROUTE: + if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*rtm))) { + rtm =3D NLMSG_DATA(nlh); + rtm->rtm_flags =3D tswap32(rtm->rtm_flags); + host_to_target_route_rtattr(RTM_RTA(rtm), + nlmsg_len - NLMSG_LENGTH(sizeof(*r= tm))); + } + break; + default: + return -TARGET_EINVAL; + } + return 0; +} + +static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh, + size_t len) +{ + return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_rou= te); +} + +static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr, + size_t len, + abi_long (*target_to_host_r= tattr) + (struct rtattr *)) +{ + abi_long ret; + + while (len >=3D sizeof(struct rtattr)) { + if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) || + tswap16(rtattr->rta_len) > len) { + break; + } + rtattr->rta_len =3D tswap16(rtattr->rta_len); + rtattr->rta_type =3D tswap16(rtattr->rta_type); + ret =3D target_to_host_rtattr(rtattr); + if (ret < 0) { + return ret; + } + len -=3D RTA_ALIGN(rtattr->rta_len); + rtattr =3D (struct rtattr *)(((char *)rtattr) + + RTA_ALIGN(rtattr->rta_len)); + } + return 0; +} + +static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr) +{ + switch (rtattr->rta_type) { + default: + gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr->rta_type); + break; + } + return 0; +} + +static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr) +{ + switch (rtattr->rta_type) { + /* binary: depends on family type */ + case IFA_LOCAL: + case IFA_ADDRESS: + break; + default: + gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type); + break; + } + return 0; +} + +static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr) +{ + uint32_t *u32; + switch (rtattr->rta_type) { + /* binary: depends on family type */ + case QEMU_RTA_DST: + case QEMU_RTA_SRC: + case QEMU_RTA_GATEWAY: + break; + /* u32 */ + case QEMU_RTA_PRIORITY: + case QEMU_RTA_OIF: + u32 =3D RTA_DATA(rtattr); + *u32 =3D tswap32(*u32); + break; + default: + gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type); + break; + } + return 0; +} + +static void target_to_host_link_rtattr(struct rtattr *rtattr, + uint32_t rtattr_len) +{ + target_to_host_for_each_rtattr(rtattr, rtattr_len, + target_to_host_data_link_rtattr); +} + +static void target_to_host_addr_rtattr(struct rtattr *rtattr, + uint32_t rtattr_len) +{ + target_to_host_for_each_rtattr(rtattr, rtattr_len, + target_to_host_data_addr_rtattr); +} + +static void target_to_host_route_rtattr(struct rtattr *rtattr, + uint32_t rtattr_len) +{ + target_to_host_for_each_rtattr(rtattr, rtattr_len, + target_to_host_data_route_rtattr); +} + +static abi_long target_to_host_data_route(struct nlmsghdr *nlh) +{ + struct ifinfomsg *ifi; + struct ifaddrmsg *ifa; + struct rtmsg *rtm; + + switch (nlh->nlmsg_type) { + case RTM_GETLINK: + break; + case RTM_NEWLINK: + case RTM_DELLINK: + if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*ifi))) { + ifi =3D NLMSG_DATA(nlh); + ifi->ifi_type =3D tswap16(ifi->ifi_type); + ifi->ifi_index =3D tswap32(ifi->ifi_index); + ifi->ifi_flags =3D tswap32(ifi->ifi_flags); + ifi->ifi_change =3D tswap32(ifi->ifi_change); + target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len - + NLMSG_LENGTH(sizeof(*ifi))); + } + break; + case RTM_GETADDR: + case RTM_NEWADDR: + case RTM_DELADDR: + if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*ifa))) { + ifa =3D NLMSG_DATA(nlh); + ifa->ifa_index =3D tswap32(ifa->ifa_index); + target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len - + NLMSG_LENGTH(sizeof(*ifa))); + } + break; + case RTM_GETROUTE: + break; + case RTM_NEWROUTE: + case RTM_DELROUTE: + if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*rtm))) { + rtm =3D NLMSG_DATA(nlh); + rtm->rtm_flags =3D tswap32(rtm->rtm_flags); + target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len - + NLMSG_LENGTH(sizeof(*rtm))); + } + break; + default: + return -TARGET_EOPNOTSUPP; + } + return 0; +} + +static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t le= n) +{ + return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_rou= te); +} +#endif /* CONFIG_RTNETLINK */ + +static abi_long host_to_target_data_audit(struct nlmsghdr *nlh) +{ + switch (nlh->nlmsg_type) { + default: + gemu_log("Unknown host audit message type %d\n", + nlh->nlmsg_type); + return -TARGET_EINVAL; + } + return 0; +} + +static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh, + size_t len) +{ + return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_aud= it); +} + +static abi_long target_to_host_data_audit(struct nlmsghdr *nlh) +{ + switch (nlh->nlmsg_type) { + case AUDIT_USER: + case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG: + case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2: + break; + default: + gemu_log("Unknown target audit message type %d\n", + nlh->nlmsg_type); + return -TARGET_EINVAL; + } + + return 0; +} + +static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t le= n) +{ + return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_aud= it); +} + +static abi_long packet_target_to_host_sockaddr(void *host_addr, + abi_ulong target_addr, + socklen_t len) +{ + struct sockaddr *addr =3D host_addr; + struct target_sockaddr *target_saddr; + + target_saddr =3D lock_user(VERIFY_READ, target_addr, len, 1); + if (!target_saddr) { + return -TARGET_EFAULT; + } + + memcpy(addr, target_saddr, len); + addr->sa_family =3D tswap16(target_saddr->sa_family); + /* spkt_protocol is big-endian */ + + unlock_user(target_saddr, target_addr, 0); + return 0; +} + +TargetFdTrans target_packet_trans =3D { + .target_to_host_addr =3D packet_target_to_host_sockaddr, +}; + +#ifdef CONFIG_RTNETLINK +static abi_long netlink_route_target_to_host(void *buf, size_t len) +{ + abi_long ret; + + ret =3D target_to_host_nlmsg_route(buf, len); + if (ret < 0) { + return ret; + } + + return len; +} + +static abi_long netlink_route_host_to_target(void *buf, size_t len) +{ + abi_long ret; + + ret =3D host_to_target_nlmsg_route(buf, len); + if (ret < 0) { + return ret; + } + + return len; +} + +TargetFdTrans target_netlink_route_trans =3D { + .target_to_host_data =3D netlink_route_target_to_host, + .host_to_target_data =3D netlink_route_host_to_target, +}; +#endif /* CONFIG_RTNETLINK */ + +static abi_long netlink_audit_target_to_host(void *buf, size_t len) +{ + abi_long ret; + + ret =3D target_to_host_nlmsg_audit(buf, len); + if (ret < 0) { + return ret; + } + + return len; +} + +static abi_long netlink_audit_host_to_target(void *buf, size_t len) +{ + abi_long ret; + + ret =3D host_to_target_nlmsg_audit(buf, len); + if (ret < 0) { + return ret; + } + + return len; +} + +TargetFdTrans target_netlink_audit_trans =3D { + .target_to_host_data =3D netlink_audit_target_to_host, + .host_to_target_data =3D netlink_audit_host_to_target, +}; + +/* signalfd siginfo conversion */ + +static void +host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo, + const struct signalfd_siginfo *info) +{ + int sig =3D host_to_target_signal(info->ssi_signo); + + /* linux/signalfd.h defines a ssi_addr_lsb + * not defined in sys/signalfd.h but used by some kernels + */ + +#ifdef BUS_MCEERR_AO + if (tinfo->ssi_signo =3D=3D SIGBUS && + (tinfo->ssi_code =3D=3D BUS_MCEERR_AR || + tinfo->ssi_code =3D=3D BUS_MCEERR_AO)) { + uint16_t *ssi_addr_lsb =3D (uint16_t *)(&info->ssi_addr + 1); + uint16_t *tssi_addr_lsb =3D (uint16_t *)(&tinfo->ssi_addr + 1); + *tssi_addr_lsb =3D tswap16(*ssi_addr_lsb); + } +#endif + + tinfo->ssi_signo =3D tswap32(sig); + tinfo->ssi_errno =3D tswap32(tinfo->ssi_errno); + tinfo->ssi_code =3D tswap32(info->ssi_code); + tinfo->ssi_pid =3D tswap32(info->ssi_pid); + tinfo->ssi_uid =3D tswap32(info->ssi_uid); + tinfo->ssi_fd =3D tswap32(info->ssi_fd); + tinfo->ssi_tid =3D tswap32(info->ssi_tid); + tinfo->ssi_band =3D tswap32(info->ssi_band); + tinfo->ssi_overrun =3D tswap32(info->ssi_overrun); + tinfo->ssi_trapno =3D tswap32(info->ssi_trapno); + tinfo->ssi_status =3D tswap32(info->ssi_status); + tinfo->ssi_int =3D tswap32(info->ssi_int); + tinfo->ssi_ptr =3D tswap64(info->ssi_ptr); + tinfo->ssi_utime =3D tswap64(info->ssi_utime); + tinfo->ssi_stime =3D tswap64(info->ssi_stime); + tinfo->ssi_addr =3D tswap64(info->ssi_addr); +} + +static abi_long host_to_target_data_signalfd(void *buf, size_t len) +{ + int i; + + for (i =3D 0; i < len; i +=3D sizeof(struct signalfd_siginfo)) { + host_to_target_signalfd_siginfo(buf + i, buf + i); + } + + return len; +} + +TargetFdTrans target_signalfd_trans =3D { + .host_to_target_data =3D host_to_target_data_signalfd, +}; + +static abi_long swap_data_eventfd(void *buf, size_t len) +{ + uint64_t *counter =3D buf; + int i; + + if (len < sizeof(uint64_t)) { + return -EINVAL; + } + + for (i =3D 0; i < len; i +=3D sizeof(uint64_t)) { + *counter =3D tswap64(*counter); + counter++; + } + + return len; +} + +TargetFdTrans target_eventfd_trans =3D { + .host_to_target_data =3D swap_data_eventfd, + .target_to_host_data =3D swap_data_eventfd, +}; + +#if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \ + (defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \ + defined(__NR_inotify_init1)) +static abi_long host_to_target_data_inotify(void *buf, size_t len) +{ + struct inotify_event *ev; + int i; + uint32_t name_len; + + for (i =3D 0; i < len; i +=3D sizeof(struct inotify_event) + name_len)= { + ev =3D (struct inotify_event *)((char *)buf + i); + name_len =3D ev->len; + + ev->wd =3D tswap32(ev->wd); + ev->mask =3D tswap32(ev->mask); + ev->cookie =3D tswap32(ev->cookie); + ev->len =3D tswap32(name_len); + } + + return len; +} + +TargetFdTrans target_inotify_trans =3D { + .host_to_target_data =3D host_to_target_data_inotify, +}; +#endif diff --git a/linux-user/fd-trans.h b/linux-user/fd-trans.h new file mode 100644 index 0000000000..a3fcdaabc7 --- /dev/null +++ b/linux-user/fd-trans.h @@ -0,0 +1,97 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#ifndef FD_TRANS_H +#define FD_TRANS_H + +typedef abi_long (*TargetFdDataFunc)(void *, size_t); +typedef abi_long (*TargetFdAddrFunc)(void *, abi_ulong, socklen_t); +typedef struct TargetFdTrans { + TargetFdDataFunc host_to_target_data; + TargetFdDataFunc target_to_host_data; + TargetFdAddrFunc target_to_host_addr; +} TargetFdTrans; + +extern TargetFdTrans **target_fd_trans; + +extern unsigned int target_fd_max; + +static inline TargetFdDataFunc fd_trans_target_to_host_data(int fd) +{ + if (fd >=3D 0 && fd < target_fd_max && target_fd_trans[fd]) { + return target_fd_trans[fd]->target_to_host_data; + } + return NULL; +} + +static inline TargetFdDataFunc fd_trans_host_to_target_data(int fd) +{ + if (fd >=3D 0 && fd < target_fd_max && target_fd_trans[fd]) { + return target_fd_trans[fd]->host_to_target_data; + } + return NULL; +} + +static inline TargetFdAddrFunc fd_trans_target_to_host_addr(int fd) +{ + if (fd >=3D 0 && fd < target_fd_max && target_fd_trans[fd]) { + return target_fd_trans[fd]->target_to_host_addr; + } + return NULL; +} + +static inline void fd_trans_register(int fd, TargetFdTrans *trans) +{ + unsigned int oldmax; + + if (fd >=3D target_fd_max) { + oldmax =3D target_fd_max; + target_fd_max =3D ((fd >> 6) + 1) << 6; /* by slice of 64 entries = */ + target_fd_trans =3D g_renew(TargetFdTrans *, + target_fd_trans, target_fd_max); + memset((void *)(target_fd_trans + oldmax), 0, + (target_fd_max - oldmax) * sizeof(TargetFdTrans *)); + } + target_fd_trans[fd] =3D trans; +} + +static inline void fd_trans_unregister(int fd) +{ + if (fd >=3D 0 && fd < target_fd_max) { + target_fd_trans[fd] =3D NULL; + } +} + +static inline void fd_trans_dup(int oldfd, int newfd) +{ + fd_trans_unregister(newfd); + if (oldfd < target_fd_max && target_fd_trans[oldfd]) { + fd_trans_register(newfd, target_fd_trans[oldfd]); + } +} + +extern TargetFdTrans target_packet_trans; +#ifdef CONFIG_RTNETLINK +extern TargetFdTrans target_netlink_route_trans; +#endif +extern TargetFdTrans target_netlink_audit_trans; +extern TargetFdTrans target_signalfd_trans; +extern TargetFdTrans target_eventfd_trans; +#if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \ + (defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \ + defined(__NR_inotify_init1)) +extern TargetFdTrans target_inotify_trans; +#endif +#endif diff --git a/linux-user/syscall.c b/linux-user/syscall.c index 850b72a0c7..e252f8b555 100644 --- a/linux-user/syscall.c +++ b/linux-user/syscall.c @@ -102,15 +102,11 @@ #include #include #include -#ifdef CONFIG_RTNETLINK -#include -#include -#endif -#include #include "linux_loop.h" #include "uname.h" =20 #include "qemu.h" +#include "fd-trans.h" =20 #ifndef CLONE_IO #define CLONE_IO 0x80000000 /* Clone io context */ @@ -360,298 +356,6 @@ static bitmask_transtbl fcntl_flags_tbl[] =3D { { 0, 0, 0, 0 } }; =20 -enum { - QEMU_IFLA_BR_UNSPEC, - QEMU_IFLA_BR_FORWARD_DELAY, - QEMU_IFLA_BR_HELLO_TIME, - QEMU_IFLA_BR_MAX_AGE, - QEMU_IFLA_BR_AGEING_TIME, - QEMU_IFLA_BR_STP_STATE, - QEMU_IFLA_BR_PRIORITY, - QEMU_IFLA_BR_VLAN_FILTERING, - QEMU_IFLA_BR_VLAN_PROTOCOL, - QEMU_IFLA_BR_GROUP_FWD_MASK, - QEMU_IFLA_BR_ROOT_ID, - QEMU_IFLA_BR_BRIDGE_ID, - QEMU_IFLA_BR_ROOT_PORT, - QEMU_IFLA_BR_ROOT_PATH_COST, - QEMU_IFLA_BR_TOPOLOGY_CHANGE, - QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED, - QEMU_IFLA_BR_HELLO_TIMER, - QEMU_IFLA_BR_TCN_TIMER, - QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER, - QEMU_IFLA_BR_GC_TIMER, - QEMU_IFLA_BR_GROUP_ADDR, - QEMU_IFLA_BR_FDB_FLUSH, - QEMU_IFLA_BR_MCAST_ROUTER, - QEMU_IFLA_BR_MCAST_SNOOPING, - QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR, - QEMU_IFLA_BR_MCAST_QUERIER, - QEMU_IFLA_BR_MCAST_HASH_ELASTICITY, - QEMU_IFLA_BR_MCAST_HASH_MAX, - QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT, - QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT, - QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL, - QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL, - QEMU_IFLA_BR_MCAST_QUERIER_INTVL, - QEMU_IFLA_BR_MCAST_QUERY_INTVL, - QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL, - QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL, - QEMU_IFLA_BR_NF_CALL_IPTABLES, - QEMU_IFLA_BR_NF_CALL_IP6TABLES, - QEMU_IFLA_BR_NF_CALL_ARPTABLES, - QEMU_IFLA_BR_VLAN_DEFAULT_PVID, - QEMU_IFLA_BR_PAD, - QEMU_IFLA_BR_VLAN_STATS_ENABLED, - QEMU_IFLA_BR_MCAST_STATS_ENABLED, - QEMU_IFLA_BR_MCAST_IGMP_VERSION, - QEMU_IFLA_BR_MCAST_MLD_VERSION, - QEMU___IFLA_BR_MAX, -}; - -enum { - QEMU_IFLA_UNSPEC, - QEMU_IFLA_ADDRESS, - QEMU_IFLA_BROADCAST, - QEMU_IFLA_IFNAME, - QEMU_IFLA_MTU, - QEMU_IFLA_LINK, - QEMU_IFLA_QDISC, - QEMU_IFLA_STATS, - QEMU_IFLA_COST, - QEMU_IFLA_PRIORITY, - QEMU_IFLA_MASTER, - QEMU_IFLA_WIRELESS, - QEMU_IFLA_PROTINFO, - QEMU_IFLA_TXQLEN, - QEMU_IFLA_MAP, - QEMU_IFLA_WEIGHT, - QEMU_IFLA_OPERSTATE, - QEMU_IFLA_LINKMODE, - QEMU_IFLA_LINKINFO, - QEMU_IFLA_NET_NS_PID, - QEMU_IFLA_IFALIAS, - QEMU_IFLA_NUM_VF, - QEMU_IFLA_VFINFO_LIST, - QEMU_IFLA_STATS64, - QEMU_IFLA_VF_PORTS, - QEMU_IFLA_PORT_SELF, - QEMU_IFLA_AF_SPEC, - QEMU_IFLA_GROUP, - QEMU_IFLA_NET_NS_FD, - QEMU_IFLA_EXT_MASK, - QEMU_IFLA_PROMISCUITY, - QEMU_IFLA_NUM_TX_QUEUES, - QEMU_IFLA_NUM_RX_QUEUES, - QEMU_IFLA_CARRIER, - QEMU_IFLA_PHYS_PORT_ID, - QEMU_IFLA_CARRIER_CHANGES, - QEMU_IFLA_PHYS_SWITCH_ID, - QEMU_IFLA_LINK_NETNSID, - QEMU_IFLA_PHYS_PORT_NAME, - QEMU_IFLA_PROTO_DOWN, - QEMU_IFLA_GSO_MAX_SEGS, - QEMU_IFLA_GSO_MAX_SIZE, - QEMU_IFLA_PAD, - QEMU_IFLA_XDP, - QEMU_IFLA_EVENT, - QEMU_IFLA_NEW_NETNSID, - QEMU_IFLA_IF_NETNSID, - QEMU_IFLA_CARRIER_UP_COUNT, - QEMU_IFLA_CARRIER_DOWN_COUNT, - QEMU_IFLA_NEW_IFINDEX, - QEMU___IFLA_MAX -}; - -enum { - QEMU_IFLA_BRPORT_UNSPEC, - QEMU_IFLA_BRPORT_STATE, - QEMU_IFLA_BRPORT_PRIORITY, - QEMU_IFLA_BRPORT_COST, - QEMU_IFLA_BRPORT_MODE, - QEMU_IFLA_BRPORT_GUARD, - QEMU_IFLA_BRPORT_PROTECT, - QEMU_IFLA_BRPORT_FAST_LEAVE, - QEMU_IFLA_BRPORT_LEARNING, - QEMU_IFLA_BRPORT_UNICAST_FLOOD, - QEMU_IFLA_BRPORT_PROXYARP, - QEMU_IFLA_BRPORT_LEARNING_SYNC, - QEMU_IFLA_BRPORT_PROXYARP_WIFI, - QEMU_IFLA_BRPORT_ROOT_ID, - QEMU_IFLA_BRPORT_BRIDGE_ID, - QEMU_IFLA_BRPORT_DESIGNATED_PORT, - QEMU_IFLA_BRPORT_DESIGNATED_COST, - QEMU_IFLA_BRPORT_ID, - QEMU_IFLA_BRPORT_NO, - QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK, - QEMU_IFLA_BRPORT_CONFIG_PENDING, - QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER, - QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER, - QEMU_IFLA_BRPORT_HOLD_TIMER, - QEMU_IFLA_BRPORT_FLUSH, - QEMU_IFLA_BRPORT_MULTICAST_ROUTER, - QEMU_IFLA_BRPORT_PAD, - QEMU_IFLA_BRPORT_MCAST_FLOOD, - QEMU_IFLA_BRPORT_MCAST_TO_UCAST, - QEMU_IFLA_BRPORT_VLAN_TUNNEL, - QEMU_IFLA_BRPORT_BCAST_FLOOD, - QEMU_IFLA_BRPORT_GROUP_FWD_MASK, - QEMU_IFLA_BRPORT_NEIGH_SUPPRESS, - QEMU___IFLA_BRPORT_MAX -}; - -enum { - QEMU_IFLA_TUN_UNSPEC, - QEMU_IFLA_TUN_OWNER, - QEMU_IFLA_TUN_GROUP, - QEMU_IFLA_TUN_TYPE, - QEMU_IFLA_TUN_PI, - QEMU_IFLA_TUN_VNET_HDR, - QEMU_IFLA_TUN_PERSIST, - QEMU_IFLA_TUN_MULTI_QUEUE, - QEMU_IFLA_TUN_NUM_QUEUES, - QEMU_IFLA_TUN_NUM_DISABLED_QUEUES, - QEMU___IFLA_TUN_MAX, -}; - -enum { - QEMU_IFLA_INFO_UNSPEC, - QEMU_IFLA_INFO_KIND, - QEMU_IFLA_INFO_DATA, - QEMU_IFLA_INFO_XSTATS, - QEMU_IFLA_INFO_SLAVE_KIND, - QEMU_IFLA_INFO_SLAVE_DATA, - QEMU___IFLA_INFO_MAX, -}; - -enum { - QEMU_IFLA_INET_UNSPEC, - QEMU_IFLA_INET_CONF, - QEMU___IFLA_INET_MAX, -}; - -enum { - QEMU_IFLA_INET6_UNSPEC, - QEMU_IFLA_INET6_FLAGS, - QEMU_IFLA_INET6_CONF, - QEMU_IFLA_INET6_STATS, - QEMU_IFLA_INET6_MCAST, - QEMU_IFLA_INET6_CACHEINFO, - QEMU_IFLA_INET6_ICMP6STATS, - QEMU_IFLA_INET6_TOKEN, - QEMU_IFLA_INET6_ADDR_GEN_MODE, - QEMU___IFLA_INET6_MAX -}; - -enum { - QEMU_IFLA_XDP_UNSPEC, - QEMU_IFLA_XDP_FD, - QEMU_IFLA_XDP_ATTACHED, - QEMU_IFLA_XDP_FLAGS, - QEMU_IFLA_XDP_PROG_ID, - QEMU___IFLA_XDP_MAX, -}; - -enum { - QEMU_RTA_UNSPEC, - QEMU_RTA_DST, - QEMU_RTA_SRC, - QEMU_RTA_IIF, - QEMU_RTA_OIF, - QEMU_RTA_GATEWAY, - QEMU_RTA_PRIORITY, - QEMU_RTA_PREFSRC, - QEMU_RTA_METRICS, - QEMU_RTA_MULTIPATH, - QEMU_RTA_PROTOINFO, /* no longer used */ - QEMU_RTA_FLOW, - QEMU_RTA_CACHEINFO, - QEMU_RTA_SESSION, /* no longer used */ - QEMU_RTA_MP_ALGO, /* no longer used */ - QEMU_RTA_TABLE, - QEMU_RTA_MARK, - QEMU_RTA_MFC_STATS, - QEMU_RTA_VIA, - QEMU_RTA_NEWDST, - QEMU_RTA_PREF, - QEMU_RTA_ENCAP_TYPE, - QEMU_RTA_ENCAP, - QEMU_RTA_EXPIRES, - QEMU_RTA_PAD, - QEMU_RTA_UID, - QEMU_RTA_TTL_PROPAGATE, - QEMU_RTA_IP_PROTO, - QEMU_RTA_SPORT, - QEMU_RTA_DPORT, - QEMU___RTA_MAX -}; - -typedef abi_long (*TargetFdDataFunc)(void *, size_t); -typedef abi_long (*TargetFdAddrFunc)(void *, abi_ulong, socklen_t); -typedef struct TargetFdTrans { - TargetFdDataFunc host_to_target_data; - TargetFdDataFunc target_to_host_data; - TargetFdAddrFunc target_to_host_addr; -} TargetFdTrans; - -static TargetFdTrans **target_fd_trans; - -static unsigned int target_fd_max; - -static TargetFdDataFunc fd_trans_target_to_host_data(int fd) -{ - if (fd >=3D 0 && fd < target_fd_max && target_fd_trans[fd]) { - return target_fd_trans[fd]->target_to_host_data; - } - return NULL; -} - -static TargetFdDataFunc fd_trans_host_to_target_data(int fd) -{ - if (fd >=3D 0 && fd < target_fd_max && target_fd_trans[fd]) { - return target_fd_trans[fd]->host_to_target_data; - } - return NULL; -} - -static TargetFdAddrFunc fd_trans_target_to_host_addr(int fd) -{ - if (fd >=3D 0 && fd < target_fd_max && target_fd_trans[fd]) { - return target_fd_trans[fd]->target_to_host_addr; - } - return NULL; -} - -static void fd_trans_register(int fd, TargetFdTrans *trans) -{ - unsigned int oldmax; - - if (fd >=3D target_fd_max) { - oldmax =3D target_fd_max; - target_fd_max =3D ((fd >> 6) + 1) << 6; /* by slice of 64 entries = */ - target_fd_trans =3D g_renew(TargetFdTrans *, - target_fd_trans, target_fd_max); - memset((void *)(target_fd_trans + oldmax), 0, - (target_fd_max - oldmax) * sizeof(TargetFdTrans *)); - } - target_fd_trans[fd] =3D trans; -} - -static void fd_trans_unregister(int fd) -{ - if (fd >=3D 0 && fd < target_fd_max) { - target_fd_trans[fd] =3D NULL; - } -} - -static void fd_trans_dup(int oldfd, int newfd) -{ - fd_trans_unregister(newfd); - if (oldfd < target_fd_max && target_fd_trans[oldfd]) { - fd_trans_register(newfd, target_fd_trans[oldfd]); - } -} - static int sys_getcwd1(char *buf, size_t size) { if (getcwd(buf, size) =3D=3D NULL) { @@ -2076,968 +1780,6 @@ static inline abi_long host_to_target_cmsg(struct t= arget_msghdr *target_msgh, return 0; } =20 -static void tswap_nlmsghdr(struct nlmsghdr *nlh) -{ - nlh->nlmsg_len =3D tswap32(nlh->nlmsg_len); - nlh->nlmsg_type =3D tswap16(nlh->nlmsg_type); - nlh->nlmsg_flags =3D tswap16(nlh->nlmsg_flags); - nlh->nlmsg_seq =3D tswap32(nlh->nlmsg_seq); - nlh->nlmsg_pid =3D tswap32(nlh->nlmsg_pid); -} - -static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh, - size_t len, - abi_long (*host_to_target_nl= msg) - (struct nlmsghdr *)) -{ - uint32_t nlmsg_len; - abi_long ret; - - while (len > sizeof(struct nlmsghdr)) { - - nlmsg_len =3D nlh->nlmsg_len; - if (nlmsg_len < sizeof(struct nlmsghdr) || - nlmsg_len > len) { - break; - } - - switch (nlh->nlmsg_type) { - case NLMSG_DONE: - tswap_nlmsghdr(nlh); - return 0; - case NLMSG_NOOP: - break; - case NLMSG_ERROR: - { - struct nlmsgerr *e =3D NLMSG_DATA(nlh); - e->error =3D tswap32(e->error); - tswap_nlmsghdr(&e->msg); - tswap_nlmsghdr(nlh); - return 0; - } - default: - ret =3D host_to_target_nlmsg(nlh); - if (ret < 0) { - tswap_nlmsghdr(nlh); - return ret; - } - break; - } - tswap_nlmsghdr(nlh); - len -=3D NLMSG_ALIGN(nlmsg_len); - nlh =3D (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len)); - } - return 0; -} - -static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh, - size_t len, - abi_long (*target_to_host_nl= msg) - (struct nlmsghdr *)) -{ - int ret; - - while (len > sizeof(struct nlmsghdr)) { - if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) || - tswap32(nlh->nlmsg_len) > len) { - break; - } - tswap_nlmsghdr(nlh); - switch (nlh->nlmsg_type) { - case NLMSG_DONE: - return 0; - case NLMSG_NOOP: - break; - case NLMSG_ERROR: - { - struct nlmsgerr *e =3D NLMSG_DATA(nlh); - e->error =3D tswap32(e->error); - tswap_nlmsghdr(&e->msg); - return 0; - } - default: - ret =3D target_to_host_nlmsg(nlh); - if (ret < 0) { - return ret; - } - } - len -=3D NLMSG_ALIGN(nlh->nlmsg_len); - nlh =3D (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg= _len)); - } - return 0; -} - -#ifdef CONFIG_RTNETLINK -static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr, - size_t len, void *context, - abi_long (*host_to_target_n= lattr) - (struct nlattr *, - void *context)) -{ - unsigned short nla_len; - abi_long ret; - - while (len > sizeof(struct nlattr)) { - nla_len =3D nlattr->nla_len; - if (nla_len < sizeof(struct nlattr) || - nla_len > len) { - break; - } - ret =3D host_to_target_nlattr(nlattr, context); - nlattr->nla_len =3D tswap16(nlattr->nla_len); - nlattr->nla_type =3D tswap16(nlattr->nla_type); - if (ret < 0) { - return ret; - } - len -=3D NLA_ALIGN(nla_len); - nlattr =3D (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len)= ); - } - return 0; -} - -static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr, - size_t len, - abi_long (*host_to_target_r= tattr) - (struct rtattr *)) -{ - unsigned short rta_len; - abi_long ret; - - while (len > sizeof(struct rtattr)) { - rta_len =3D rtattr->rta_len; - if (rta_len < sizeof(struct rtattr) || - rta_len > len) { - break; - } - ret =3D host_to_target_rtattr(rtattr); - rtattr->rta_len =3D tswap16(rtattr->rta_len); - rtattr->rta_type =3D tswap16(rtattr->rta_type); - if (ret < 0) { - return ret; - } - len -=3D RTA_ALIGN(rta_len); - rtattr =3D (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len)= ); - } - return 0; -} - -#define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN) - -static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr, - void *context) -{ - uint16_t *u16; - uint32_t *u32; - uint64_t *u64; - - switch (nlattr->nla_type) { - /* no data */ - case QEMU_IFLA_BR_FDB_FLUSH: - break; - /* binary */ - case QEMU_IFLA_BR_GROUP_ADDR: - break; - /* uint8_t */ - case QEMU_IFLA_BR_VLAN_FILTERING: - case QEMU_IFLA_BR_TOPOLOGY_CHANGE: - case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED: - case QEMU_IFLA_BR_MCAST_ROUTER: - case QEMU_IFLA_BR_MCAST_SNOOPING: - case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR: - case QEMU_IFLA_BR_MCAST_QUERIER: - case QEMU_IFLA_BR_NF_CALL_IPTABLES: - case QEMU_IFLA_BR_NF_CALL_IP6TABLES: - case QEMU_IFLA_BR_NF_CALL_ARPTABLES: - case QEMU_IFLA_BR_VLAN_STATS_ENABLED: - case QEMU_IFLA_BR_MCAST_STATS_ENABLED: - case QEMU_IFLA_BR_MCAST_IGMP_VERSION: - case QEMU_IFLA_BR_MCAST_MLD_VERSION: - break; - /* uint16_t */ - case QEMU_IFLA_BR_PRIORITY: - case QEMU_IFLA_BR_VLAN_PROTOCOL: - case QEMU_IFLA_BR_GROUP_FWD_MASK: - case QEMU_IFLA_BR_ROOT_PORT: - case QEMU_IFLA_BR_VLAN_DEFAULT_PVID: - u16 =3D NLA_DATA(nlattr); - *u16 =3D tswap16(*u16); - break; - /* uint32_t */ - case QEMU_IFLA_BR_FORWARD_DELAY: - case QEMU_IFLA_BR_HELLO_TIME: - case QEMU_IFLA_BR_MAX_AGE: - case QEMU_IFLA_BR_AGEING_TIME: - case QEMU_IFLA_BR_STP_STATE: - case QEMU_IFLA_BR_ROOT_PATH_COST: - case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY: - case QEMU_IFLA_BR_MCAST_HASH_MAX: - case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT: - case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT: - u32 =3D NLA_DATA(nlattr); - *u32 =3D tswap32(*u32); - break; - /* uint64_t */ - case QEMU_IFLA_BR_HELLO_TIMER: - case QEMU_IFLA_BR_TCN_TIMER: - case QEMU_IFLA_BR_GC_TIMER: - case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER: - case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL: - case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL: - case QEMU_IFLA_BR_MCAST_QUERIER_INTVL: - case QEMU_IFLA_BR_MCAST_QUERY_INTVL: - case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL: - case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL: - u64 =3D NLA_DATA(nlattr); - *u64 =3D tswap64(*u64); - break; - /* ifla_bridge_id: uin8_t[] */ - case QEMU_IFLA_BR_ROOT_ID: - case QEMU_IFLA_BR_BRIDGE_ID: - break; - default: - gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr->nla_type); - break; - } - return 0; -} - -static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nla= ttr, - void *context) -{ - uint16_t *u16; - uint32_t *u32; - uint64_t *u64; - - switch (nlattr->nla_type) { - /* uint8_t */ - case QEMU_IFLA_BRPORT_STATE: - case QEMU_IFLA_BRPORT_MODE: - case QEMU_IFLA_BRPORT_GUARD: - case QEMU_IFLA_BRPORT_PROTECT: - case QEMU_IFLA_BRPORT_FAST_LEAVE: - case QEMU_IFLA_BRPORT_LEARNING: - case QEMU_IFLA_BRPORT_UNICAST_FLOOD: - case QEMU_IFLA_BRPORT_PROXYARP: - case QEMU_IFLA_BRPORT_LEARNING_SYNC: - case QEMU_IFLA_BRPORT_PROXYARP_WIFI: - case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK: - case QEMU_IFLA_BRPORT_CONFIG_PENDING: - case QEMU_IFLA_BRPORT_MULTICAST_ROUTER: - case QEMU_IFLA_BRPORT_MCAST_FLOOD: - case QEMU_IFLA_BRPORT_MCAST_TO_UCAST: - case QEMU_IFLA_BRPORT_VLAN_TUNNEL: - case QEMU_IFLA_BRPORT_BCAST_FLOOD: - case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS: - break; - /* uint16_t */ - case QEMU_IFLA_BRPORT_PRIORITY: - case QEMU_IFLA_BRPORT_DESIGNATED_PORT: - case QEMU_IFLA_BRPORT_DESIGNATED_COST: - case QEMU_IFLA_BRPORT_ID: - case QEMU_IFLA_BRPORT_NO: - case QEMU_IFLA_BRPORT_GROUP_FWD_MASK: - u16 =3D NLA_DATA(nlattr); - *u16 =3D tswap16(*u16); - break; - /* uin32_t */ - case QEMU_IFLA_BRPORT_COST: - u32 =3D NLA_DATA(nlattr); - *u32 =3D tswap32(*u32); - break; - /* uint64_t */ - case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER: - case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER: - case QEMU_IFLA_BRPORT_HOLD_TIMER: - u64 =3D NLA_DATA(nlattr); - *u64 =3D tswap64(*u64); - break; - /* ifla_bridge_id: uint8_t[] */ - case QEMU_IFLA_BRPORT_ROOT_ID: - case QEMU_IFLA_BRPORT_BRIDGE_ID: - break; - default: - gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr->nla_type); - break; - } - return 0; -} - -static abi_long host_to_target_data_tun_nlattr(struct nlattr *nlattr, - void *context) -{ - uint32_t *u32; - - switch (nlattr->nla_type) { - /* uint8_t */ - case QEMU_IFLA_TUN_TYPE: - case QEMU_IFLA_TUN_PI: - case QEMU_IFLA_TUN_VNET_HDR: - case QEMU_IFLA_TUN_PERSIST: - case QEMU_IFLA_TUN_MULTI_QUEUE: - break; - /* uint32_t */ - case QEMU_IFLA_TUN_NUM_QUEUES: - case QEMU_IFLA_TUN_NUM_DISABLED_QUEUES: - case QEMU_IFLA_TUN_OWNER: - case QEMU_IFLA_TUN_GROUP: - u32 =3D NLA_DATA(nlattr); - *u32 =3D tswap32(*u32); - break; - default: - gemu_log("Unknown QEMU_IFLA_TUN type %d\n", nlattr->nla_type); - break; - } - return 0; -} - -struct linkinfo_context { - int len; - char *name; - int slave_len; - char *slave_name; -}; - -static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr, - void *context) -{ - struct linkinfo_context *li_context =3D context; - - switch (nlattr->nla_type) { - /* string */ - case QEMU_IFLA_INFO_KIND: - li_context->name =3D NLA_DATA(nlattr); - li_context->len =3D nlattr->nla_len - NLA_HDRLEN; - break; - case QEMU_IFLA_INFO_SLAVE_KIND: - li_context->slave_name =3D NLA_DATA(nlattr); - li_context->slave_len =3D nlattr->nla_len - NLA_HDRLEN; - break; - /* stats */ - case QEMU_IFLA_INFO_XSTATS: - /* FIXME: only used by CAN */ - break; - /* nested */ - case QEMU_IFLA_INFO_DATA: - if (strncmp(li_context->name, "bridge", - li_context->len) =3D=3D 0) { - return host_to_target_for_each_nlattr(NLA_DATA(nlattr), - nlattr->nla_len, - NULL, - host_to_target_data_bridge_nl= attr); - } else if (strncmp(li_context->name, "tun", - li_context->len) =3D=3D 0) { - return host_to_target_for_each_nlattr(NLA_DATA(nlattr), - nlattr->nla_len, - NULL, - host_to_target_data_tun_nl= attr); - } else { - gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context->name); - } - break; - case QEMU_IFLA_INFO_SLAVE_DATA: - if (strncmp(li_context->slave_name, "bridge", - li_context->slave_len) =3D=3D 0) { - return host_to_target_for_each_nlattr(NLA_DATA(nlattr), - nlattr->nla_len, - NULL, - host_to_target_slave_data_bridge_nl= attr); - } else { - gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n", - li_context->slave_name); - } - break; - default: - gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr->nla_typ= e); - break; - } - - return 0; -} - -static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr, - void *context) -{ - uint32_t *u32; - int i; - - switch (nlattr->nla_type) { - case QEMU_IFLA_INET_CONF: - u32 =3D NLA_DATA(nlattr); - for (i =3D 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32); - i++) { - u32[i] =3D tswap32(u32[i]); - } - break; - default: - gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type); - } - return 0; -} - -static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr, - void *context) -{ - uint32_t *u32; - uint64_t *u64; - struct ifla_cacheinfo *ci; - int i; - - switch (nlattr->nla_type) { - /* binaries */ - case QEMU_IFLA_INET6_TOKEN: - break; - /* uint8_t */ - case QEMU_IFLA_INET6_ADDR_GEN_MODE: - break; - /* uint32_t */ - case QEMU_IFLA_INET6_FLAGS: - u32 =3D NLA_DATA(nlattr); - *u32 =3D tswap32(*u32); - break; - /* uint32_t[] */ - case QEMU_IFLA_INET6_CONF: - u32 =3D NLA_DATA(nlattr); - for (i =3D 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32); - i++) { - u32[i] =3D tswap32(u32[i]); - } - break; - /* ifla_cacheinfo */ - case QEMU_IFLA_INET6_CACHEINFO: - ci =3D NLA_DATA(nlattr); - ci->max_reasm_len =3D tswap32(ci->max_reasm_len); - ci->tstamp =3D tswap32(ci->tstamp); - ci->reachable_time =3D tswap32(ci->reachable_time); - ci->retrans_time =3D tswap32(ci->retrans_time); - break; - /* uint64_t[] */ - case QEMU_IFLA_INET6_STATS: - case QEMU_IFLA_INET6_ICMP6STATS: - u64 =3D NLA_DATA(nlattr); - for (i =3D 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64); - i++) { - u64[i] =3D tswap64(u64[i]); - } - break; - default: - gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type); - } - return 0; -} - -static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr, - void *context) -{ - switch (nlattr->nla_type) { - case AF_INET: - return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nl= a_len, - NULL, - host_to_target_data_inet_nlat= tr); - case AF_INET6: - return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nl= a_len, - NULL, - host_to_target_data_inet6_nla= ttr); - default: - gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type); - break; - } - return 0; -} - -static abi_long host_to_target_data_xdp_nlattr(struct nlattr *nlattr, - void *context) -{ - uint32_t *u32; - - switch (nlattr->nla_type) { - /* uint8_t */ - case QEMU_IFLA_XDP_ATTACHED: - break; - /* uint32_t */ - case QEMU_IFLA_XDP_PROG_ID: - u32 =3D NLA_DATA(nlattr); - *u32 =3D tswap32(*u32); - break; - default: - gemu_log("Unknown host XDP type: %d\n", nlattr->nla_type); - break; - } - return 0; -} - -static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr) -{ - uint32_t *u32; - struct rtnl_link_stats *st; - struct rtnl_link_stats64 *st64; - struct rtnl_link_ifmap *map; - struct linkinfo_context li_context; - - switch (rtattr->rta_type) { - /* binary stream */ - case QEMU_IFLA_ADDRESS: - case QEMU_IFLA_BROADCAST: - /* string */ - case QEMU_IFLA_IFNAME: - case QEMU_IFLA_QDISC: - break; - /* uin8_t */ - case QEMU_IFLA_OPERSTATE: - case QEMU_IFLA_LINKMODE: - case QEMU_IFLA_CARRIER: - case QEMU_IFLA_PROTO_DOWN: - break; - /* uint32_t */ - case QEMU_IFLA_MTU: - case QEMU_IFLA_LINK: - case QEMU_IFLA_WEIGHT: - case QEMU_IFLA_TXQLEN: - case QEMU_IFLA_CARRIER_CHANGES: - case QEMU_IFLA_NUM_RX_QUEUES: - case QEMU_IFLA_NUM_TX_QUEUES: - case QEMU_IFLA_PROMISCUITY: - case QEMU_IFLA_EXT_MASK: - case QEMU_IFLA_LINK_NETNSID: - case QEMU_IFLA_GROUP: - case QEMU_IFLA_MASTER: - case QEMU_IFLA_NUM_VF: - case QEMU_IFLA_GSO_MAX_SEGS: - case QEMU_IFLA_GSO_MAX_SIZE: - case QEMU_IFLA_CARRIER_UP_COUNT: - case QEMU_IFLA_CARRIER_DOWN_COUNT: - u32 =3D RTA_DATA(rtattr); - *u32 =3D tswap32(*u32); - break; - /* struct rtnl_link_stats */ - case QEMU_IFLA_STATS: - st =3D RTA_DATA(rtattr); - st->rx_packets =3D tswap32(st->rx_packets); - st->tx_packets =3D tswap32(st->tx_packets); - st->rx_bytes =3D tswap32(st->rx_bytes); - st->tx_bytes =3D tswap32(st->tx_bytes); - st->rx_errors =3D tswap32(st->rx_errors); - st->tx_errors =3D tswap32(st->tx_errors); - st->rx_dropped =3D tswap32(st->rx_dropped); - st->tx_dropped =3D tswap32(st->tx_dropped); - st->multicast =3D tswap32(st->multicast); - st->collisions =3D tswap32(st->collisions); - - /* detailed rx_errors: */ - st->rx_length_errors =3D tswap32(st->rx_length_errors); - st->rx_over_errors =3D tswap32(st->rx_over_errors); - st->rx_crc_errors =3D tswap32(st->rx_crc_errors); - st->rx_frame_errors =3D tswap32(st->rx_frame_errors); - st->rx_fifo_errors =3D tswap32(st->rx_fifo_errors); - st->rx_missed_errors =3D tswap32(st->rx_missed_errors); - - /* detailed tx_errors */ - st->tx_aborted_errors =3D tswap32(st->tx_aborted_errors); - st->tx_carrier_errors =3D tswap32(st->tx_carrier_errors); - st->tx_fifo_errors =3D tswap32(st->tx_fifo_errors); - st->tx_heartbeat_errors =3D tswap32(st->tx_heartbeat_errors); - st->tx_window_errors =3D tswap32(st->tx_window_errors); - - /* for cslip etc */ - st->rx_compressed =3D tswap32(st->rx_compressed); - st->tx_compressed =3D tswap32(st->tx_compressed); - break; - /* struct rtnl_link_stats64 */ - case QEMU_IFLA_STATS64: - st64 =3D RTA_DATA(rtattr); - st64->rx_packets =3D tswap64(st64->rx_packets); - st64->tx_packets =3D tswap64(st64->tx_packets); - st64->rx_bytes =3D tswap64(st64->rx_bytes); - st64->tx_bytes =3D tswap64(st64->tx_bytes); - st64->rx_errors =3D tswap64(st64->rx_errors); - st64->tx_errors =3D tswap64(st64->tx_errors); - st64->rx_dropped =3D tswap64(st64->rx_dropped); - st64->tx_dropped =3D tswap64(st64->tx_dropped); - st64->multicast =3D tswap64(st64->multicast); - st64->collisions =3D tswap64(st64->collisions); - - /* detailed rx_errors: */ - st64->rx_length_errors =3D tswap64(st64->rx_length_errors); - st64->rx_over_errors =3D tswap64(st64->rx_over_errors); - st64->rx_crc_errors =3D tswap64(st64->rx_crc_errors); - st64->rx_frame_errors =3D tswap64(st64->rx_frame_errors); - st64->rx_fifo_errors =3D tswap64(st64->rx_fifo_errors); - st64->rx_missed_errors =3D tswap64(st64->rx_missed_errors); - - /* detailed tx_errors */ - st64->tx_aborted_errors =3D tswap64(st64->tx_aborted_errors); - st64->tx_carrier_errors =3D tswap64(st64->tx_carrier_errors); - st64->tx_fifo_errors =3D tswap64(st64->tx_fifo_errors); - st64->tx_heartbeat_errors =3D tswap64(st64->tx_heartbeat_errors); - st64->tx_window_errors =3D tswap64(st64->tx_window_errors); - - /* for cslip etc */ - st64->rx_compressed =3D tswap64(st64->rx_compressed); - st64->tx_compressed =3D tswap64(st64->tx_compressed); - break; - /* struct rtnl_link_ifmap */ - case QEMU_IFLA_MAP: - map =3D RTA_DATA(rtattr); - map->mem_start =3D tswap64(map->mem_start); - map->mem_end =3D tswap64(map->mem_end); - map->base_addr =3D tswap64(map->base_addr); - map->irq =3D tswap16(map->irq); - break; - /* nested */ - case QEMU_IFLA_LINKINFO: - memset(&li_context, 0, sizeof(li_context)); - return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rt= a_len, - &li_context, - host_to_target_data_linkinfo_nl= attr); - case QEMU_IFLA_AF_SPEC: - return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rt= a_len, - NULL, - host_to_target_data_spec_nlat= tr); - case QEMU_IFLA_XDP: - return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rt= a_len, - NULL, - host_to_target_data_xdp_nl= attr); - default: - gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr->rta_type); - break; - } - return 0; -} - -static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr) -{ - uint32_t *u32; - struct ifa_cacheinfo *ci; - - switch (rtattr->rta_type) { - /* binary: depends on family type */ - case IFA_ADDRESS: - case IFA_LOCAL: - break; - /* string */ - case IFA_LABEL: - break; - /* u32 */ - case IFA_FLAGS: - case IFA_BROADCAST: - u32 =3D RTA_DATA(rtattr); - *u32 =3D tswap32(*u32); - break; - /* struct ifa_cacheinfo */ - case IFA_CACHEINFO: - ci =3D RTA_DATA(rtattr); - ci->ifa_prefered =3D tswap32(ci->ifa_prefered); - ci->ifa_valid =3D tswap32(ci->ifa_valid); - ci->cstamp =3D tswap32(ci->cstamp); - ci->tstamp =3D tswap32(ci->tstamp); - break; - default: - gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type); - break; - } - return 0; -} - -static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr) -{ - uint32_t *u32; - struct rta_cacheinfo *ci; - - switch (rtattr->rta_type) { - /* binary: depends on family type */ - case QEMU_RTA_GATEWAY: - case QEMU_RTA_DST: - case QEMU_RTA_PREFSRC: - break; - /* u8 */ - case QEMU_RTA_PREF: - break; - /* u32 */ - case QEMU_RTA_PRIORITY: - case QEMU_RTA_TABLE: - case QEMU_RTA_OIF: - u32 =3D RTA_DATA(rtattr); - *u32 =3D tswap32(*u32); - break; - /* struct rta_cacheinfo */ - case QEMU_RTA_CACHEINFO: - ci =3D RTA_DATA(rtattr); - ci->rta_clntref =3D tswap32(ci->rta_clntref); - ci->rta_lastuse =3D tswap32(ci->rta_lastuse); - ci->rta_expires =3D tswap32(ci->rta_expires); - ci->rta_error =3D tswap32(ci->rta_error); - ci->rta_used =3D tswap32(ci->rta_used); -#if defined(RTNETLINK_HAVE_PEERINFO) - ci->rta_id =3D tswap32(ci->rta_id); - ci->rta_ts =3D tswap32(ci->rta_ts); - ci->rta_tsage =3D tswap32(ci->rta_tsage); -#endif - break; - default: - gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type); - break; - } - return 0; -} - -static abi_long host_to_target_link_rtattr(struct rtattr *rtattr, - uint32_t rtattr_len) -{ - return host_to_target_for_each_rtattr(rtattr, rtattr_len, - host_to_target_data_link_rtattr); -} - -static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr, - uint32_t rtattr_len) -{ - return host_to_target_for_each_rtattr(rtattr, rtattr_len, - host_to_target_data_addr_rtattr); -} - -static abi_long host_to_target_route_rtattr(struct rtattr *rtattr, - uint32_t rtattr_len) -{ - return host_to_target_for_each_rtattr(rtattr, rtattr_len, - host_to_target_data_route_rtattr= ); -} - -static abi_long host_to_target_data_route(struct nlmsghdr *nlh) -{ - uint32_t nlmsg_len; - struct ifinfomsg *ifi; - struct ifaddrmsg *ifa; - struct rtmsg *rtm; - - nlmsg_len =3D nlh->nlmsg_len; - switch (nlh->nlmsg_type) { - case RTM_NEWLINK: - case RTM_DELLINK: - case RTM_GETLINK: - if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*ifi))) { - ifi =3D NLMSG_DATA(nlh); - ifi->ifi_type =3D tswap16(ifi->ifi_type); - ifi->ifi_index =3D tswap32(ifi->ifi_index); - ifi->ifi_flags =3D tswap32(ifi->ifi_flags); - ifi->ifi_change =3D tswap32(ifi->ifi_change); - host_to_target_link_rtattr(IFLA_RTA(ifi), - nlmsg_len - NLMSG_LENGTH(sizeof(*if= i))); - } - break; - case RTM_NEWADDR: - case RTM_DELADDR: - case RTM_GETADDR: - if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*ifa))) { - ifa =3D NLMSG_DATA(nlh); - ifa->ifa_index =3D tswap32(ifa->ifa_index); - host_to_target_addr_rtattr(IFA_RTA(ifa), - nlmsg_len - NLMSG_LENGTH(sizeof(*if= a))); - } - break; - case RTM_NEWROUTE: - case RTM_DELROUTE: - case RTM_GETROUTE: - if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*rtm))) { - rtm =3D NLMSG_DATA(nlh); - rtm->rtm_flags =3D tswap32(rtm->rtm_flags); - host_to_target_route_rtattr(RTM_RTA(rtm), - nlmsg_len - NLMSG_LENGTH(sizeof(*r= tm))); - } - break; - default: - return -TARGET_EINVAL; - } - return 0; -} - -static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh, - size_t len) -{ - return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_rou= te); -} - -static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr, - size_t len, - abi_long (*target_to_host_r= tattr) - (struct rtattr *)) -{ - abi_long ret; - - while (len >=3D sizeof(struct rtattr)) { - if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) || - tswap16(rtattr->rta_len) > len) { - break; - } - rtattr->rta_len =3D tswap16(rtattr->rta_len); - rtattr->rta_type =3D tswap16(rtattr->rta_type); - ret =3D target_to_host_rtattr(rtattr); - if (ret < 0) { - return ret; - } - len -=3D RTA_ALIGN(rtattr->rta_len); - rtattr =3D (struct rtattr *)(((char *)rtattr) + - RTA_ALIGN(rtattr->rta_len)); - } - return 0; -} - -static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr) -{ - switch (rtattr->rta_type) { - default: - gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr->rta_type); - break; - } - return 0; -} - -static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr) -{ - switch (rtattr->rta_type) { - /* binary: depends on family type */ - case IFA_LOCAL: - case IFA_ADDRESS: - break; - default: - gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type); - break; - } - return 0; -} - -static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr) -{ - uint32_t *u32; - switch (rtattr->rta_type) { - /* binary: depends on family type */ - case QEMU_RTA_DST: - case QEMU_RTA_SRC: - case QEMU_RTA_GATEWAY: - break; - /* u32 */ - case QEMU_RTA_PRIORITY: - case QEMU_RTA_OIF: - u32 =3D RTA_DATA(rtattr); - *u32 =3D tswap32(*u32); - break; - default: - gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type); - break; - } - return 0; -} - -static void target_to_host_link_rtattr(struct rtattr *rtattr, - uint32_t rtattr_len) -{ - target_to_host_for_each_rtattr(rtattr, rtattr_len, - target_to_host_data_link_rtattr); -} - -static void target_to_host_addr_rtattr(struct rtattr *rtattr, - uint32_t rtattr_len) -{ - target_to_host_for_each_rtattr(rtattr, rtattr_len, - target_to_host_data_addr_rtattr); -} - -static void target_to_host_route_rtattr(struct rtattr *rtattr, - uint32_t rtattr_len) -{ - target_to_host_for_each_rtattr(rtattr, rtattr_len, - target_to_host_data_route_rtattr); -} - -static abi_long target_to_host_data_route(struct nlmsghdr *nlh) -{ - struct ifinfomsg *ifi; - struct ifaddrmsg *ifa; - struct rtmsg *rtm; - - switch (nlh->nlmsg_type) { - case RTM_GETLINK: - break; - case RTM_NEWLINK: - case RTM_DELLINK: - if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*ifi))) { - ifi =3D NLMSG_DATA(nlh); - ifi->ifi_type =3D tswap16(ifi->ifi_type); - ifi->ifi_index =3D tswap32(ifi->ifi_index); - ifi->ifi_flags =3D tswap32(ifi->ifi_flags); - ifi->ifi_change =3D tswap32(ifi->ifi_change); - target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len - - NLMSG_LENGTH(sizeof(*ifi))); - } - break; - case RTM_GETADDR: - case RTM_NEWADDR: - case RTM_DELADDR: - if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*ifa))) { - ifa =3D NLMSG_DATA(nlh); - ifa->ifa_index =3D tswap32(ifa->ifa_index); - target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len - - NLMSG_LENGTH(sizeof(*ifa))); - } - break; - case RTM_GETROUTE: - break; - case RTM_NEWROUTE: - case RTM_DELROUTE: - if (nlh->nlmsg_len >=3D NLMSG_LENGTH(sizeof(*rtm))) { - rtm =3D NLMSG_DATA(nlh); - rtm->rtm_flags =3D tswap32(rtm->rtm_flags); - target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len - - NLMSG_LENGTH(sizeof(*rtm))); - } - break; - default: - return -TARGET_EOPNOTSUPP; - } - return 0; -} - -static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t le= n) -{ - return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_rou= te); -} -#endif /* CONFIG_RTNETLINK */ - -static abi_long host_to_target_data_audit(struct nlmsghdr *nlh) -{ - switch (nlh->nlmsg_type) { - default: - gemu_log("Unknown host audit message type %d\n", - nlh->nlmsg_type); - return -TARGET_EINVAL; - } - return 0; -} - -static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh, - size_t len) -{ - return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_aud= it); -} - -static abi_long target_to_host_data_audit(struct nlmsghdr *nlh) -{ - switch (nlh->nlmsg_type) { - case AUDIT_USER: - case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG: - case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2: - break; - default: - gemu_log("Unknown target audit message type %d\n", - nlh->nlmsg_type); - return -TARGET_EINVAL; - } - - return 0; -} - -static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t le= n) -{ - return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_aud= it); -} - /* do_setsockopt() Must return target values and target errnos. */ static abi_long do_setsockopt(int sockfd, int level, int optname, abi_ulong optval_addr, socklen_t optlen) @@ -3733,90 +2475,6 @@ static int sock_flags_fixup(int fd, int target_type) return fd; } =20 -static abi_long packet_target_to_host_sockaddr(void *host_addr, - abi_ulong target_addr, - socklen_t len) -{ - struct sockaddr *addr =3D host_addr; - struct target_sockaddr *target_saddr; - - target_saddr =3D lock_user(VERIFY_READ, target_addr, len, 1); - if (!target_saddr) { - return -TARGET_EFAULT; - } - - memcpy(addr, target_saddr, len); - addr->sa_family =3D tswap16(target_saddr->sa_family); - /* spkt_protocol is big-endian */ - - unlock_user(target_saddr, target_addr, 0); - return 0; -} - -static TargetFdTrans target_packet_trans =3D { - .target_to_host_addr =3D packet_target_to_host_sockaddr, -}; - -#ifdef CONFIG_RTNETLINK -static abi_long netlink_route_target_to_host(void *buf, size_t len) -{ - abi_long ret; - - ret =3D target_to_host_nlmsg_route(buf, len); - if (ret < 0) { - return ret; - } - - return len; -} - -static abi_long netlink_route_host_to_target(void *buf, size_t len) -{ - abi_long ret; - - ret =3D host_to_target_nlmsg_route(buf, len); - if (ret < 0) { - return ret; - } - - return len; -} - -static TargetFdTrans target_netlink_route_trans =3D { - .target_to_host_data =3D netlink_route_target_to_host, - .host_to_target_data =3D netlink_route_host_to_target, -}; -#endif /* CONFIG_RTNETLINK */ - -static abi_long netlink_audit_target_to_host(void *buf, size_t len) -{ - abi_long ret; - - ret =3D target_to_host_nlmsg_audit(buf, len); - if (ret < 0) { - return ret; - } - - return len; -} - -static abi_long netlink_audit_host_to_target(void *buf, size_t len) -{ - abi_long ret; - - ret =3D host_to_target_nlmsg_audit(buf, len); - if (ret < 0) { - return ret; - } - - return len; -} - -static TargetFdTrans target_netlink_audit_trans =3D { - .target_to_host_data =3D netlink_audit_target_to_host, - .host_to_target_data =3D netlink_audit_host_to_target, -}; - /* do_socket() Must return target values and target errnos. */ static abi_long do_socket(int domain, int type, int protocol) { @@ -7596,61 +6254,6 @@ static abi_long do_open_by_handle_at(abi_long mount_= fd, abi_long handle, =20 #if defined(TARGET_NR_signalfd) || defined(TARGET_NR_signalfd4) =20 -/* signalfd siginfo conversion */ - -static void -host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo, - const struct signalfd_siginfo *info) -{ - int sig =3D host_to_target_signal(info->ssi_signo); - - /* linux/signalfd.h defines a ssi_addr_lsb - * not defined in sys/signalfd.h but used by some kernels - */ - -#ifdef BUS_MCEERR_AO - if (tinfo->ssi_signo =3D=3D SIGBUS && - (tinfo->ssi_code =3D=3D BUS_MCEERR_AR || - tinfo->ssi_code =3D=3D BUS_MCEERR_AO)) { - uint16_t *ssi_addr_lsb =3D (uint16_t *)(&info->ssi_addr + 1); - uint16_t *tssi_addr_lsb =3D (uint16_t *)(&tinfo->ssi_addr + 1); - *tssi_addr_lsb =3D tswap16(*ssi_addr_lsb); - } -#endif - - tinfo->ssi_signo =3D tswap32(sig); - tinfo->ssi_errno =3D tswap32(tinfo->ssi_errno); - tinfo->ssi_code =3D tswap32(info->ssi_code); - tinfo->ssi_pid =3D tswap32(info->ssi_pid); - tinfo->ssi_uid =3D tswap32(info->ssi_uid); - tinfo->ssi_fd =3D tswap32(info->ssi_fd); - tinfo->ssi_tid =3D tswap32(info->ssi_tid); - tinfo->ssi_band =3D tswap32(info->ssi_band); - tinfo->ssi_overrun =3D tswap32(info->ssi_overrun); - tinfo->ssi_trapno =3D tswap32(info->ssi_trapno); - tinfo->ssi_status =3D tswap32(info->ssi_status); - tinfo->ssi_int =3D tswap32(info->ssi_int); - tinfo->ssi_ptr =3D tswap64(info->ssi_ptr); - tinfo->ssi_utime =3D tswap64(info->ssi_utime); - tinfo->ssi_stime =3D tswap64(info->ssi_stime); - tinfo->ssi_addr =3D tswap64(info->ssi_addr); -} - -static abi_long host_to_target_data_signalfd(void *buf, size_t len) -{ - int i; - - for (i =3D 0; i < len; i +=3D sizeof(struct signalfd_siginfo)) { - host_to_target_signalfd_siginfo(buf + i, buf + i); - } - - return len; -} - -static TargetFdTrans target_signalfd_trans =3D { - .host_to_target_data =3D host_to_target_data_signalfd, -}; - static abi_long do_signalfd4(int fd, abi_long mask, int flags) { int host_flags; @@ -7976,55 +6579,6 @@ static target_timer_t get_timer_id(abi_long arg) return timerid; } =20 -static abi_long swap_data_eventfd(void *buf, size_t len) -{ - uint64_t *counter =3D buf; - int i; - - if (len < sizeof(uint64_t)) { - return -EINVAL; - } - - for (i =3D 0; i < len; i +=3D sizeof(uint64_t)) { - *counter =3D tswap64(*counter); - counter++; - } - - return len; -} - -static TargetFdTrans target_eventfd_trans =3D { - .host_to_target_data =3D swap_data_eventfd, - .target_to_host_data =3D swap_data_eventfd, -}; - -#if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \ - (defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \ - defined(__NR_inotify_init1)) -static abi_long host_to_target_data_inotify(void *buf, size_t len) -{ - struct inotify_event *ev; - int i; - uint32_t name_len; - - for (i =3D 0; i < len; i +=3D sizeof(struct inotify_event) + name_len)= { - ev =3D (struct inotify_event *)((char *)buf + i); - name_len =3D ev->len; - - ev->wd =3D tswap32(ev->wd); - ev->mask =3D tswap32(ev->mask); - ev->cookie =3D tswap32(ev->cookie); - ev->len =3D tswap32(name_len); - } - - return len; -} - -static TargetFdTrans target_inotify_trans =3D { - .host_to_target_data =3D host_to_target_data_inotify, -}; -#endif - static int target_to_host_cpu_mask(unsigned long *host_mask, size_t host_size, abi_ulong target_addr, --=20 2.17.1 From nobody Sat Apr 27 13:34:06 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (208.118.235.17 [208.118.235.17]) by mx.zohomail.com with SMTPS id 1537908868551775.3058752734723; Tue, 25 Sep 2018 13:54:28 -0700 (PDT) Received: from localhost ([::1]:55215 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uLi-00012i-A7 for importer@patchew.org; Tue, 25 Sep 2018 16:54:26 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:53892) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uJU-0008EL-9H for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:09 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1g4uJP-0002Ee-SW for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:08 -0400 Received: from mout.kundenserver.de ([212.227.126.130]:35843) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1g4uJP-0002E2-Jc for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:03 -0400 Received: from localhost.localdomain ([78.238.229.36]) by mrelayeu.kundenserver.de (mreue009 [212.227.15.167]) with ESMTPSA (Nemesis) id 1MBltM-1fv1s420HU-00C8fU; Tue, 25 Sep 2018 22:51:52 +0200 From: Laurent Vivier To: qemu-devel@nongnu.org Date: Tue, 25 Sep 2018 22:51:26 +0200 Message-Id: <20180925205129.25261-3-laurent@vivier.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180925205129.25261-1-laurent@vivier.eu> References: <20180925205129.25261-1-laurent@vivier.eu> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:CXxiFAzWUFDcUqxCxaPKXiu4LZhuBQhdw+7Dwx+77C+EXKU3DJO hCPweevZnv+FY/PRi3UWApH33Z/b08vNpy4pFtCZMPdlcbWiSKJlhXib2JOBGKYMOhWeIqR klSyln2iGQws9dse56mrjFnjILEXaswW01JelJAMIw4p1LbqRavHNnzRO7V6ddRRQ5SBwLI y1i7bjaEyfNTuSYTRBR9Q== X-UI-Out-Filterresults: notjunk:1;V01:K0:2e0I2yLOopA=:j5UXCNomKeDA+MxMRxxwNY IJ0LxXt21kkK5qnbG2KT7EiV41g2lD0nQue4AnOd6Grx3Tdnl1rMvI+nO5Ar1M9f5qtngcOAf dWXe8zIrdxnEm8wZrGmdWsLehB6GDPamohFDAsTZqngnCaZXBeGJrbKOHYO5cX7sGMN0kX2/I zs/1r+sgq+PJ5FKXGXFO62kyrjTw7QWfHEbsBZrKI+6xGBFOD77R7VgKdWuI8trUYdt/GT6PB 58lSnbSPXPSF5B7/B+aAKMMYYn7M4Bu2/PD2bmoOnyWAPWFYM17FXKgSJa31uFShVBFFpbX9p pMz4cj5dzYKYhkZE+kuWbavXmm8IBmHl10bVpwoFTVil1tj6sONyg+SU6R4s08ez3NS0vrDKB pxZWsV8+Iz7qb2oCWNz61ffe5WjFCB/B/MTQUBeQ4W6ePbsFaZum/mTVEePF5OCvMbScY7Iyv 5j/40ExAuP2RDukZle1Ogl5xVn7eIeyjPq2JvVXop22gZcE5/bwjzX1sXIWAtfiFcPexExV3O hC+Rw4yVbAwLQcenP/LL5Jf2B3vYSU6we67VywMMGm4nZY2TAnfPn7mb9d63xGGy41Y+hhvg1 FWLfPreU5fvzMBreWVtViMqI71fy0S6Kd77cWvPVJHYIkDVyZsoIhYUXnhaDsvTaEEny+tkgV ZhUdxD9MSyfKdN+GfTZRK11V8LpWVZbOky2j9iV9e9yhyW4SEuFnLnB/LTBhAFdgruuhJ53ub l4JfAmJvGJFYA1mm X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 212.227.126.130 Subject: [Qemu-devel] [PULL v2 2/5] linux-user: add SO_LINGER to {g, s}etsockopt X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Carlo=20Marcelo=20Arenas=20Bel=C3=B3n?= , Riku Voipio , Laurent Vivier Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 From: Carlo Marcelo Arenas Bel=C3=B3n Original implementation for setsockopt by Chen Gang[1]; all bugs mine, including removing assignment for optname which hopefully makes the logic easier to follow and moving some variables to make the code more selfcontained. [1] http://patchwork.ozlabs.org/patch/565659/ Signed-off-by: Carlo Marcelo Arenas Bel=C3=B3n Co-Authored-By: Chen Gang Reviewed-by: Laurent Vivier Message-Id: <20180824085601.6259-1-carenas@gmail.com> Signed-off-by: Laurent Vivier --- linux-user/syscall.c | 52 ++++++++++++++++++++++++++++++++++++++- linux-user/syscall_defs.h | 5 ++++ 2 files changed, 56 insertions(+), 1 deletion(-) diff --git a/linux-user/syscall.c b/linux-user/syscall.c index e252f8b555..58fb967499 100644 --- a/linux-user/syscall.c +++ b/linux-user/syscall.c @@ -2032,6 +2032,24 @@ set_timeout: unlock_user (dev_ifname, optval_addr, 0); return ret; } + case TARGET_SO_LINGER: + { + struct linger lg; + struct target_linger *tlg; + + if (optlen !=3D sizeof(struct target_linger)) { + return -TARGET_EINVAL; + } + if (!lock_user_struct(VERIFY_READ, tlg, optval_addr, 1)) { + return -TARGET_EFAULT; + } + __get_user(lg.l_onoff, &tlg->l_onoff); + __get_user(lg.l_linger, &tlg->l_linger); + ret =3D get_errno(setsockopt(sockfd, SOL_SOCKET, SO_LINGER, + &lg, sizeof(lg))); + unlock_user_struct(tlg, optval_addr, 0); + return ret; + } /* Options with 'int' argument. */ case TARGET_SO_DEBUG: optname =3D SO_DEBUG; @@ -2123,7 +2141,6 @@ static abi_long do_getsockopt(int sockfd, int level, = int optname, level =3D SOL_SOCKET; switch (optname) { /* These don't just return a single integer */ - case TARGET_SO_LINGER: case TARGET_SO_RCVTIMEO: case TARGET_SO_SNDTIMEO: case TARGET_SO_PEERNAME: @@ -2161,6 +2178,39 @@ static abi_long do_getsockopt(int sockfd, int level,= int optname, } break; } + case TARGET_SO_LINGER: + { + struct linger lg; + socklen_t lglen; + struct target_linger *tlg; + + if (get_user_u32(len, optlen)) { + return -TARGET_EFAULT; + } + if (len < 0) { + return -TARGET_EINVAL; + } + + lglen =3D sizeof(lg); + ret =3D get_errno(getsockopt(sockfd, level, SO_LINGER, + &lg, &lglen)); + if (ret < 0) { + return ret; + } + if (len > lglen) { + len =3D lglen; + } + if (!lock_user_struct(VERIFY_WRITE, tlg, optval_addr, 0)) { + return -TARGET_EFAULT; + } + __put_user(lg.l_onoff, &tlg->l_onoff); + __put_user(lg.l_linger, &tlg->l_linger); + unlock_user_struct(tlg, optval_addr, 1); + if (put_user_u32(len, optlen)) { + return -TARGET_EFAULT; + } + break; + } /* Options with 'int' argument. */ case TARGET_SO_DEBUG: optname =3D SO_DEBUG; diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h index 40bb60ef4c..18d434d6dc 100644 --- a/linux-user/syscall_defs.h +++ b/linux-user/syscall_defs.h @@ -203,6 +203,11 @@ struct target_ip_mreq_source { uint32_t imr_sourceaddr; }; =20 +struct target_linger { + abi_int l_onoff; /* Linger active */ + abi_int l_linger; /* How long to linger for */ +}; + struct target_timeval { abi_long tv_sec; abi_long tv_usec; --=20 2.17.1 From nobody Sat Apr 27 13:34:06 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1537908883617208.15503738323514; Tue, 25 Sep 2018 13:54:43 -0700 (PDT) Received: from localhost ([::1]:55216 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uLs-0001AD-9W for importer@patchew.org; Tue, 25 Sep 2018 16:54:36 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:53899) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uJW-0008GF-Su for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:15 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1g4uJS-0002G3-0s for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:10 -0400 Received: from mout.kundenserver.de ([212.227.126.187]:46111) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1g4uJR-0002F8-7x for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:05 -0400 Received: from localhost.localdomain ([78.238.229.36]) by mrelayeu.kundenserver.de (mreue009 [212.227.15.167]) with ESMTPSA (Nemesis) id 1N2m7Q-1fdMQf2284-0138nM; Tue, 25 Sep 2018 22:51:53 +0200 From: Laurent Vivier To: qemu-devel@nongnu.org Date: Tue, 25 Sep 2018 22:51:27 +0200 Message-Id: <20180925205129.25261-4-laurent@vivier.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180925205129.25261-1-laurent@vivier.eu> References: <20180925205129.25261-1-laurent@vivier.eu> X-Provags-ID: V03:K1:z1HCpHOIocdjodJcQRy1LSws/xBkaQx9BGXX+qbx51VsMfUefHR +fdHF0hj7coAoSS58fho+j8RQSSlFGxkUT9MCv2qtTEzc497euNfOVkgTkul18DJVZHrY4B fk4dPEW5IjEQK3Y70XYfsHgqWtbgRXH4ollcO5PapjiIWmt/x6TfWxaAIbOuSZp2DQ8uHc7 zpQe677M4oaXquYZOADzw== X-UI-Out-Filterresults: notjunk:1;V01:K0:luoLuABJVz4=:Czwf+M3+QYSKHhHypW4jQ0 E+0r7niD9y0sTXgLNw8PAfSwY9KIBn2tfpVifAqCj0MdaczVRF80q1Pa8ZafUvBjdFiRVN2Dw VZ9XmvocMKoDwWzUJzVmyIhcR8e+bioNBLdmI81evhFcoeUv7dbrw6cLcSy9QKHCWyz/r91n2 uhdRDVGDlQk8ghHvVdk9dEC2JxRnDvVM0T6hHt2pOD/l3J2M1uZlX8bVdETn0Ty8jDTRcAJc6 iZIcDTztvCM13CCfrFHumyWasyaWylgKMd5+dI0eLfZ9kKKF1QNcKcGMRp7FYE3DpR6MwuYZK LpI6nbwSk3a1NVWscr9X2/eAf3TQ9Yn9H3TxoKpBmcUAzG94VuBt1L2NVAEG9I/MQzq39MLWT AnSNsJtqojqu8LmG2zY+SlEzarRQCGCnuFh2IZpOZRlpdlUUr7vd4V3kLubZpx8ZY/3a6ow0y l7IqZRyYB2PN//SGy6hXCVv5b3a7WB3AoS4vFad9gl/Q1d+JRUwZJ+iI4vuqSKpE7alP4xD+b 4F2LKWhL4EA9vf5QTMgD3nOvFTVyYt4ZI34CqUwwpk8DqZ+8kCYz/3KgrFJKCygpDN98UMDPV Qjs9AoB7voQnWZoLtFS8SZeUA+Gi1TgJnc0RsMbFRax0f3IGQ8jC75BpxF/8sSoIRGyvk/Ici qh85afJP/sguPmj3DiMEmP+DD1zzLMkrPOsby9Qa4a8bDYhId7Kj0otq7N3ihIZLWbpg= X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 212.227.126.187 Subject: [Qemu-devel] [PULL v2 3/5] linux-user: elf: mmap all the target-pages of hostpage for data segment X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Riku Voipio , Shivaprasad G Bhat , Laurent Vivier Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: Shivaprasad G Bhat If the hostpage size is greater than the TARGET_PAGESIZE, the target-pages of size TARGET_PAGESIZE are marked valid only till the length requested during the elfload. The glibc attempts to consume unused space in the last page of data segment(__libc_memalign() in elf/dl-minimal.c). If PT_LOAD p_align is greater than or equal to hostpage size, the GLRO(dl_pagesize) is actually the host pagesize as set in the auxillary vectors. So, there is no explicit mmap request for the remaining target-pages on the last hostpage. The glibc assumes that particular space as available and subsequent attempts to use those addresses lead to crash as the target_mmap has not marked them valid for those target-pages. The issue is seen when trying to chroot to 16.04-x86_64 ubuntu on a PPC64 host where the fork fails to access the thread_id as it is allocated on a page not marked valid. The recent glibc doesn't have checks for thread-id in fork, but the issue can manifest somewhere else, none the less. The fix here is to map all the target-pages of the hostpage during the elfload if the p_align is greater than or equal to hostpage size, for data segment to allow the glibc for proper consumption. Signed-off-by: Shivaprasad G Bhat Reviewed-by: Laurent Vivier Message-Id: <153553435604.51992.5640085189104207249.stgit@lep8c.aus.stglabs= .ibm.com> Signed-off-by: Laurent Vivier --- linux-user/elfload.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/linux-user/elfload.c b/linux-user/elfload.c index 8638612aec..6ead0d11c6 100644 --- a/linux-user/elfload.c +++ b/linux-user/elfload.c @@ -1437,7 +1437,10 @@ struct exec #define QMAGIC 0314 =20 /* Necessary parameters */ -#define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE +#define TARGET_ELF_EXEC_PAGESIZE \ + (((eppnt->p_align & ~qemu_host_page_mask) !=3D 0) ? \ + TARGET_PAGE_SIZE : MAX(qemu_host_page_size, TARGET_PAGE_SIZE)) +#define TARGET_ELF_PAGELENGTH(_v) ROUND_UP((_v), TARGET_ELF_EXEC_PAGESIZE) #define TARGET_ELF_PAGESTART(_v) ((_v) & \ ~(abi_ulong)(TARGET_ELF_EXEC_PAGESIZE-1)) #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1)) @@ -2279,7 +2282,7 @@ static void load_elf_image(const char *image_name, in= t image_fd, for (i =3D 0; i < ehdr->e_phnum; i++) { struct elf_phdr *eppnt =3D phdr + i; if (eppnt->p_type =3D=3D PT_LOAD) { - abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em; + abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em, vaddr= _len; int elf_prot =3D 0; =20 if (eppnt->p_flags & PF_R) elf_prot =3D PROT_READ; @@ -2289,8 +2292,9 @@ static void load_elf_image(const char *image_name, in= t image_fd, vaddr =3D load_bias + eppnt->p_vaddr; vaddr_po =3D TARGET_ELF_PAGEOFFSET(vaddr); vaddr_ps =3D TARGET_ELF_PAGESTART(vaddr); + vaddr_len =3D TARGET_ELF_PAGELENGTH(eppnt->p_filesz + vaddr_po= ); =20 - error =3D target_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po, + error =3D target_mmap(vaddr_ps, vaddr_len, elf_prot, MAP_PRIVATE | MAP_FIXED, image_fd, eppnt->p_offset - vaddr_po); if (error =3D=3D -1) { --=20 2.17.1 From nobody Sat Apr 27 13:34:06 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1537909015009679.0804959193654; Tue, 25 Sep 2018 13:56:55 -0700 (PDT) Received: from localhost ([::1]:55234 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uO5-0002te-UQ for importer@patchew.org; Tue, 25 Sep 2018 16:56:53 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:53982) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uJu-0000C0-DQ for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:35 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1g4uJq-0002WA-Km for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:34 -0400 Received: from mout.kundenserver.de ([212.227.126.131]:37051) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1g4uJq-0002VT-BD for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:30 -0400 Received: from localhost.localdomain ([78.238.229.36]) by mrelayeu.kundenserver.de (mreue009 [212.227.15.167]) with ESMTPSA (Nemesis) id 1MKsaz-1gLjfj0Pev-00LFL3; Tue, 25 Sep 2018 22:51:54 +0200 From: Laurent Vivier To: qemu-devel@nongnu.org Date: Tue, 25 Sep 2018 22:51:28 +0200 Message-Id: <20180925205129.25261-5-laurent@vivier.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180925205129.25261-1-laurent@vivier.eu> References: <20180925205129.25261-1-laurent@vivier.eu> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-Provags-ID: V03:K1:9MGHT2GmUE15XMlbdJ2j7kQnWuxDmTu8hItxYkoQqrgkHHM64kQ A5uPO/+St52huehOXIvt/Uvoex6tsb+fh+HDa2GJj03D61X0zFjoTdpJOoUgTDfnX/cswJJ zMC32IVr8ZtL0XiVLwDHSNQwmPnReIQMjtoy/8TA3utE+Unji0qi9AMK4CViNRStk5FoJij d1STj3ZbADhpKmzUi3e+g== X-UI-Out-Filterresults: notjunk:1;V01:K0:uSt/lc53pkA=:M0MfvEgpetJNien6pUmLxp CscSnJJq9UcwxnkCKQhANk6ej5pPwYqx5n3kUuFcBp+5SKnemrZVTYDIDMbyMUClXGH5xS81N lzOF9fk8+Y629Rmgct9I97mMjTHvCsZeIt420p7wfDUoNLNLQ3buOn69erpxrqTDeGY20E6ig f0Ocn446NVyAEiucT8ZzZiprBgBkVJbGnZzn53b2PQhXd0FyF/f8vmlHpSNya2Pf62XSQQeAb r2N53Ybny7ur5onv7BJi60TNhKuJ/NUP8Huet9b6Z5e0jDmzGIAR2/WMzqwtyGu54wjEpI7cl ub3a74TzvDiGDnjoG2aVeYHsyRtEIl/ZrCzwgiMXmzMpGmSpTJKbNxn1vjSR63yhWbeLWTxOg gvAXZJKWhQKFi5+Y5j5HmekHYs5oL+FdExP3bqVBYNkoG6wAtkTXCBNTlWui8gOt173BrumS9 Ht5LM6vyGlid9dv+tlqpNEvF0fwRbnGbxeklzB6zuPMXncyJbJJ7LqR3ET8ATdHkGeWJfkZpI AdHfdwZ0smyXSFGWuniItbwCmQNi+LIhZZ8Pa17faF5ePhK34uZrefvIorW24v6RO7CMtWNKy bnU/C714dJKGXjXxNa9Qzk6ifzzeqGiugHR5Ir3dAW/PYZT5WaNBo6m6XV9OoXGw2ipG8Brcw PQdi0Csg/qhLg4/7Bs3BFAORZlyx6FL0n4CEb86KpW7uyx9P8dETjf57X/A6yztT3UXQEme0v 5gU+Jv7ATisqQlVj X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 212.227.126.131 Subject: [Qemu-devel] [PULL v2 4/5] linux-user: write(fd, NULL, 0) parity with linux's treatment of same X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Tony Garnock-Jones , Riku Voipio , Laurent Vivier , Tony Garnock-Jones Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 From: Tony Garnock-Jones Bring linux-user write(2) handling into line with linux for the case of a 0-byte write with a NULL buffer. Based on a patch originally written by Zhuowei Zhang. Addresses https://bugs.launchpad.net/qemu/+bug/1716292. >From Zhuowei Zhang's patch (https://lists.gnu.org/archive/html/qemu-devel/= 2017-09/msg08073.html): Linux returns success for the special case of calling write with a zero-length NULL buffer: compiling and running int main() { ssize_t ret =3D write(STDOUT_FILENO, NULL, 0); fprintf(stderr, "write returned %ld\n", ret); return 0; } gives "write returned 0" when run directly, but "write returned -1" in QEMU. This commit checks for this situation and returns success if found. Subsequent discussion raised the following questions (and my answers): - Q. Should TARGET_NR_read pass through to safe_read in this situation too? A. I'm wary of changing unrelated code to the specific problem I'm addressing. TARGET_NR_read is already consistent with Linux for this case. - Q. Do pread64/pwrite64 need to be changed similarly? A. Experiment suggests not: both linux and linux-user yield -1 for NULL 0-length reads/writes. Signed-off-by: Tony Garnock-Jones Reviewed-by: Philippe Mathieu-Daud=C3=A9 Reviewed-by: Laurent Vivier Message-Id: <20180908182205.GB409@mornington.dcs.gla.ac.uk> Signed-off-by: Laurent Vivier --- linux-user/syscall.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/linux-user/syscall.c b/linux-user/syscall.c index 58fb967499..019af632df 100644 --- a/linux-user/syscall.c +++ b/linux-user/syscall.c @@ -6772,6 +6772,9 @@ static abi_long do_syscall1(void *cpu_env, int num, a= bi_long arg1, } return ret; case TARGET_NR_write: + if (arg2 =3D=3D 0 && arg3 =3D=3D 0) { + return get_errno(safe_write(arg1, 0, 0)); + } if (!(p =3D lock_user(VERIFY_READ, arg2, arg3, 1))) return -TARGET_EFAULT; if (fd_trans_target_to_host_data(arg1)) { --=20 2.17.1 From nobody Sat Apr 27 13:34:06 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (208.118.235.17 [208.118.235.17]) by mx.zohomail.com with SMTPS id 1537908868534998.943556770774; Tue, 25 Sep 2018 13:54:28 -0700 (PDT) Received: from localhost ([::1]:55214 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uLe-000105-7i for importer@patchew.org; Tue, 25 Sep 2018 16:54:22 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:53885) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1g4uJT-0008EK-Pz for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:08 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1g4uJP-0002EI-Dn for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:07 -0400 Received: from mout.kundenserver.de ([212.227.126.130]:52581) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1g4uJP-0002Da-4W for qemu-devel@nongnu.org; Tue, 25 Sep 2018 16:52:03 -0400 Received: from localhost.localdomain ([78.238.229.36]) by mrelayeu.kundenserver.de (mreue009 [212.227.15.167]) with ESMTPSA (Nemesis) id 1MBDva-1fuTdk2gEo-00Cgtq; Tue, 25 Sep 2018 22:51:54 +0200 From: Laurent Vivier To: qemu-devel@nongnu.org Date: Tue, 25 Sep 2018 22:51:29 +0200 Message-Id: <20180925205129.25261-6-laurent@vivier.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180925205129.25261-1-laurent@vivier.eu> References: <20180925205129.25261-1-laurent@vivier.eu> X-Provags-ID: V03:K1:f8B6Ft4k5shA7pJQW9/qGpJUxXpBwbDQma+TWR37cshvOyHy0yJ xl4jJoIP5qCEN5udmk6i3RMI7is0jhDEQo1VsMeDqBSIDFjwSE8Fw+h0FUGr+cJVLR4L88I oIPQWw3qw7eoAP3I8EopKInKnQvXotEC90zXmI2qWadYXSXxw1tnjHs3KYifRjOJj506lgO EqnuVg8vdAvb/jYTi0Ihw== X-UI-Out-Filterresults: notjunk:1;V01:K0:fNKuY/iFdCA=:prCNYaCwzevDy7nr8t3D41 AzSJSUrRNyceqsX68PVfYrguaJKBoSAQTappZExZmdcpMASS5mAmJ+2yCMk1X92zBR4UUfIbg vPDLuSNrG1z/hTtsl0Xa9ZpYTR8+qzhozEnspVqG5hGNQJaDuUOpfyQbJMcsR7PnuV1VJCo7w UFznM9zONAaTokkGy9Oar06878vgCgzvkW2Urb/T7wPnE4PVZ3oa+FN+TfdXaK/aF7U8GYmmU oq3SFLKyDE0ViLLS3wsW6H3O19bsM+UHrn3/2p/+U/S0O5iSB7F217L4xrYZy3s9K2e/sOvX2 tl1z8xxA1Y3lclNa0SPCBpBVdzT3pGR0LNCBAufNNk2SDW7P3BO66xUgLqavtSZf/6AhUtXKE YVt4zB+mXPbry5R+OfkMdsMCuMgGZAVPe1Mym7sZyzcVFcuoiYxczXbikAvLoihBI4YJWUZwJ EImTtnsZcinzt2Dk4EqMNx6vVCPbRXJ3LUNfIQXYKcE8ImVWAzgg5Xsl84HX6yx7y9lfF++76 LFc1CYkdCWl6TmPHZDnLJ1yNNbscyrNfa2SMQvCYrLtYVUJ/3dBRXKda17c1H+M3WnDdVoL+p pOl/RvnesRO5cup2CWxqDZsaIr30KDgX7rRM3hCAafv8ztVs7Nthd1cIrdDFm4y0Kxo1/fts6 VKPymcgEoRhDd2zpzcCDZNy/Y9gCbqylhdRp6TBdW6xiFAFT19DEcylnucvLNiQMSqPU= X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 212.227.126.130 Subject: [Qemu-devel] [PULL v2 5/5] linux-user: do setrlimit selectively X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Max Filippov , Riku Voipio , Laurent Vivier Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: Max Filippov setrlimit guest calls that affect memory resources (RLIMIT_{AS,DATA,STACK}) may interfere with QEMU internal memory management. They may result in QEMU lockup because mprotect call in page_unprotect would fail with ENOMEM error code, causing infinite loop of SIGSEGV. E.g. it happens when running libstdc++ testsuite for xtensa target on x86_64 host. Don't call host setrlimit for memory-related resources. Reviewed-by: Peter Maydell Signed-off-by: Max Filippov Message-Id: <20180917181314.22551-1-jcmvbkbc@gmail.com> [lv: rebase on master] Signed-off-by: Laurent Vivier --- linux-user/syscall.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/linux-user/syscall.c b/linux-user/syscall.c index 019af632df..ae3c0dfef7 100644 --- a/linux-user/syscall.c +++ b/linux-user/syscall.c @@ -7879,7 +7879,21 @@ static abi_long do_syscall1(void *cpu_env, int num, = abi_long arg1, rlim.rlim_cur =3D target_to_host_rlim(target_rlim->rlim_cur); rlim.rlim_max =3D target_to_host_rlim(target_rlim->rlim_max); unlock_user_struct(target_rlim, arg2, 0); - return get_errno(setrlimit(resource, &rlim)); + /* + * If we just passed through resource limit settings for memor= y then + * they would also apply to QEMU's own allocations, and QEMU w= ill + * crash or hang or die if its allocations fail. Ideally we wo= uld + * track the guest allocations in QEMU and apply the limits ou= rselves. + * For now, just tell the guest the call succeeded but don't a= ctually + * limit anything. + */ + if (resource !=3D RLIMIT_AS && + resource !=3D RLIMIT_DATA && + resource !=3D RLIMIT_STACK) { + return get_errno(setrlimit(resource, &rlim)); + } else { + return 0; + } } #endif #ifdef TARGET_NR_getrlimit --=20 2.17.1