From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3A1E3CA9ECF for ; Mon, 4 Nov 2019 15:15:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 07EB820663 for ; Mon, 4 Nov 2019 15:15:52 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=oracle.com header.i=@oracle.com header.b="pHnvkMlH" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729175AbfKDPPv (ORCPT ); Mon, 4 Nov 2019 10:15:51 -0500 Received: from aserp2120.oracle.com ([141.146.126.78]:54502 "EHLO aserp2120.oracle.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727796AbfKDPPu (ORCPT ); Mon, 4 Nov 2019 10:15:50 -0500 Received: from pps.filterd (aserp2120.oracle.com [127.0.0.1]) by aserp2120.oracle.com (8.16.0.27/8.16.0.27) with SMTP id xA4FCP0v032260; Mon, 4 Nov 2019 15:14:32 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references; s=corp-2019-08-05; bh=85K7fC2AblLC2FOwgaSUFn+yoZ4NbAzwtxs7nqvsiEU=; b=pHnvkMlHIICf/ZFx5eq2Ya8tvOJZGaUne/n2aLj/2SkIj0yYG4TVVg5Az2Wjw6TTz4Rt 48f5ClSW+FIjxnh/DjMAVKfRFqInqksN9QDBFCeGhYnWHASGbjYqTv5YsmBdFB8ZFail L1RK3ZrNDGdHcTWgqBpDMAiSFPDDeJ8MLKh0LFELSwGUTgIS1hlIbz6ZgsXhLnW09MCY N62KOTtecuzzyiuNR1oIrSlJMHNe4zXY/Z25ueeU4FnHI1eUANRKnF2BjQPktn3AKwcX SQ6OAMtRuQ3GlQjkidUW4cyo92ZyTQUk1Sj8V6RVPjVrb++m3R2HiWx4V8CIj3HJpUXi 7w== Received: from aserp3030.oracle.com (aserp3030.oracle.com [141.146.126.71]) by aserp2120.oracle.com with ESMTP id 2w11rpr13u-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Mon, 04 Nov 2019 15:14:32 +0000 Received: from pps.filterd (aserp3030.oracle.com [127.0.0.1]) by aserp3030.oracle.com (8.16.0.27/8.16.0.27) with SMTP id xA4FABIi020092; Mon, 4 Nov 2019 15:14:32 GMT Received: from userv0121.oracle.com (userv0121.oracle.com [156.151.31.72]) by aserp3030.oracle.com with ESMTP id 2w1kxmhhg0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Mon, 04 Nov 2019 15:14:31 +0000 Received: from abhmp0015.oracle.com (abhmp0015.oracle.com [141.146.116.21]) by userv0121.oracle.com (8.14.4/8.13.8) with ESMTP id xA4FEUfo018320; Mon, 4 Nov 2019 15:14:30 GMT Received: from tomti.i.net-space.pl (/10.175.168.29) by default (Oracle Beehive Gateway v4.0) with ESMTP ; Mon, 04 Nov 2019 07:14:29 -0800 From: Daniel Kiper To: linux-efi@vger.kernel.org, linux-kernel@vger.kernel.org, x86@kernel.org, xen-devel@lists.xenproject.org Cc: ard.biesheuvel@linaro.org, boris.ostrovsky@oracle.com, bp@alien8.de, corbet@lwn.net, dave.hansen@linux.intel.com, luto@kernel.org, peterz@infradead.org, eric.snowberg@oracle.com, hpa@zytor.com, jgross@suse.com, kanth.ghatraju@oracle.com, konrad.wilk@oracle.com, mingo@redhat.com, rdunlap@infradead.org, ross.philipson@oracle.com, tglx@linutronix.de Subject: [PATCH v5 3/3] x86/boot: Introduce the setup_indirect Date: Mon, 4 Nov 2019 16:13:54 +0100 Message-Id: <20191104151354.28145-4-daniel.kiper@oracle.com> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20191104151354.28145-1-daniel.kiper@oracle.com> References: <20191104151354.28145-1-daniel.kiper@oracle.com> X-Proofpoint-Virus-Version: vendor=nai engine=6000 definitions=9431 signatures=668685 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=0 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 mlxscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1911040151 X-Proofpoint-Virus-Version: vendor=nai engine=6000 definitions=9431 signatures=668685 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 priorityscore=1501 malwarescore=0 suspectscore=0 phishscore=0 bulkscore=0 spamscore=0 clxscore=1015 lowpriorityscore=0 mlxscore=0 impostorscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1911040151 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The setup_data is a bit awkward to use for extremely large data objects, both because the setup_data header has to be adjacent to the data object and because it has a 32-bit length field. However, it is important that intermediate stages of the boot process have a way to identify which chunks of memory are occupied by kernel data. Thus we introduce an uniform way to specify such indirect data as setup_indirect struct and SETUP_INDIRECT type. And finally bump setup_header version in arch/x86/boot/header.S. Suggested-by: H. Peter Anvin (Intel) Signed-off-by: Daniel Kiper Acked-by: Konrad Rzeszutek Wilk Reviewed-by: Ross Philipson Reviewed-by: H. Peter Anvin (Intel) --- v5 - suggestions/fixes: - bump setup_header version in arch/x86/boot/header.S (suggested by H. Peter Anvin). v4 - suggestions/fixes: - change "Note:" to ".. note::". v3 - suggestions/fixes: - add setup_indirect mapping/KASLR avoidance/etc. code (suggested by H. Peter Anvin), - the SETUP_INDIRECT sets most significant bit right now; this way it is possible to differentiate regular setup_data and setup_indirect objects in the debugfs filesystem. v2 - suggestions/fixes: - add setup_indirect usage example (suggested by Eric Snowberg and Ross Philipson). --- Documentation/x86/boot.rst | 43 +++++++++++++++++++++++++++++++++- arch/x86/boot/compressed/kaslr.c | 12 ++++++++++ arch/x86/boot/compressed/kernel_info.S | 2 +- arch/x86/boot/header.S | 2 +- arch/x86/include/uapi/asm/bootparam.h | 16 ++++++++++--- arch/x86/kernel/e820.c | 11 +++++++++ arch/x86/kernel/kdebugfs.c | 20 ++++++++++++---- arch/x86/kernel/ksysfs.c | 30 ++++++++++++++++++------ arch/x86/kernel/setup.c | 4 ++++ arch/x86/mm/ioremap.c | 11 +++++++++ 10 files changed, 134 insertions(+), 17 deletions(-) diff --git a/Documentation/x86/boot.rst b/Documentation/x86/boot.rst index 1dad6eee8a5c..38155ba8740f 100644 --- a/Documentation/x86/boot.rst +++ b/Documentation/x86/boot.rst @@ -827,6 +827,47 @@ Protocol: 2.09+ sure to consider the case where the linked list already contains entries. + The setup_data is a bit awkward to use for extremely large data objects, + both because the setup_data header has to be adjacent to the data object + and because it has a 32-bit length field. However, it is important that + intermediate stages of the boot process have a way to identify which + chunks of memory are occupied by kernel data. + + Thus setup_indirect struct and SETUP_INDIRECT type were introduced in + protocol 2.15. + + struct setup_indirect { + __u32 type; + __u32 reserved; /* Reserved, must be set to zero. */ + __u64 len; + __u64 addr; + }; + + The type member is a SETUP_INDIRECT | SETUP_* type. However, it cannot be + SETUP_INDIRECT itself since making the setup_indirect a tree structure + could require a lot of stack space in something that needs to parse it + and stack space can be limited in boot contexts. + + Let's give an example how to point to SETUP_E820_EXT data using setup_indirect. + In this case setup_data and setup_indirect will look like this: + + struct setup_data { + __u64 next = 0 or ; + __u32 type = SETUP_INDIRECT; + __u32 len = sizeof(setup_data); + __u8 data[sizeof(setup_indirect)] = struct setup_indirect { + __u32 type = SETUP_INDIRECT | SETUP_E820_EXT; + __u32 reserved = 0; + __u64 len = ; + __u64 addr = ; + } + } + +.. note:: + SETUP_INDIRECT | SETUP_NONE objects cannot be properly distinguished + from SETUP_INDIRECT itself. So, this kind of objects cannot be provided + by the bootloaders. + ============ ============ Field name: pref_address Type: read (reloc) @@ -986,7 +1027,7 @@ Field name: setup_type_max Offset/size: 0x0008/4 ============ ============== - This field contains maximal allowed type for setup_data. + This field contains maximal allowed type for setup_data and setup_indirect structs. The Image Checksum diff --git a/arch/x86/boot/compressed/kaslr.c b/arch/x86/boot/compressed/kaslr.c index 2e53c056ba20..bb9bfef174ae 100644 --- a/arch/x86/boot/compressed/kaslr.c +++ b/arch/x86/boot/compressed/kaslr.c @@ -459,6 +459,18 @@ static bool mem_avoid_overlap(struct mem_vector *img, is_overlapping = true; } + if (ptr->type == SETUP_INDIRECT && + ((struct setup_indirect *)ptr->data)->type != SETUP_INDIRECT) { + avoid.start = ((struct setup_indirect *)ptr->data)->addr; + avoid.size = ((struct setup_indirect *)ptr->data)->len; + + if (mem_overlaps(img, &avoid) && (avoid.start < earliest)) { + *overlap = avoid; + earliest = overlap->start; + is_overlapping = true; + } + } + ptr = (struct setup_data *)(unsigned long)ptr->next; } diff --git a/arch/x86/boot/compressed/kernel_info.S b/arch/x86/boot/compressed/kernel_info.S index 018dacbd753e..f818ee8fba38 100644 --- a/arch/x86/boot/compressed/kernel_info.S +++ b/arch/x86/boot/compressed/kernel_info.S @@ -14,7 +14,7 @@ kernel_info: /* Size total. */ .long kernel_info_end - kernel_info - /* Maximal allowed type for setup_data. */ + /* Maximal allowed type for setup_data and setup_indirect structs. */ .long SETUP_TYPE_MAX kernel_info_var_len_data: diff --git a/arch/x86/boot/header.S b/arch/x86/boot/header.S index 22dcecaaa898..97d9b6d6c1af 100644 --- a/arch/x86/boot/header.S +++ b/arch/x86/boot/header.S @@ -300,7 +300,7 @@ _start: # Part 2 of the header, from the old setup.S .ascii "HdrS" # header signature - .word 0x020d # header version number (>= 0x0105) + .word 0x020f # header version number (>= 0x0105) # or else old loadlin-1.5 will fail) .globl realmode_swtch realmode_swtch: .word 0, 0 # default_switch, SETUPSEG diff --git a/arch/x86/include/uapi/asm/bootparam.h b/arch/x86/include/uapi/asm/bootparam.h index dbb41128e5a0..949066b5398a 100644 --- a/arch/x86/include/uapi/asm/bootparam.h +++ b/arch/x86/include/uapi/asm/bootparam.h @@ -2,7 +2,7 @@ #ifndef _ASM_X86_BOOTPARAM_H #define _ASM_X86_BOOTPARAM_H -/* setup_data types */ +/* setup_data/setup_indirect types */ #define SETUP_NONE 0 #define SETUP_E820_EXT 1 #define SETUP_DTB 2 @@ -11,8 +11,10 @@ #define SETUP_APPLE_PROPERTIES 5 #define SETUP_JAILHOUSE 6 -/* max(SETUP_*) */ -#define SETUP_TYPE_MAX SETUP_JAILHOUSE +#define SETUP_INDIRECT (1<<31) + +/* SETUP_INDIRECT | max(SETUP_*) */ +#define SETUP_TYPE_MAX (SETUP_INDIRECT | SETUP_JAILHOUSE) /* ram_size flags */ #define RAMDISK_IMAGE_START_MASK 0x07FF @@ -52,6 +54,14 @@ struct setup_data { __u8 data[0]; }; +/* extensible setup indirect data node */ +struct setup_indirect { + __u32 type; + __u32 reserved; /* Reserved, must be set to zero. */ + __u64 len; + __u64 addr; +}; + struct setup_header { __u8 setup_sects; __u16 root_flags; diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c index 7da2bcd2b8eb..0bfe9a685b3b 100644 --- a/arch/x86/kernel/e820.c +++ b/arch/x86/kernel/e820.c @@ -999,6 +999,17 @@ void __init e820__reserve_setup_data(void) data = early_memremap(pa_data, sizeof(*data)); e820__range_update(pa_data, sizeof(*data)+data->len, E820_TYPE_RAM, E820_TYPE_RESERVED_KERN); e820__range_update_kexec(pa_data, sizeof(*data)+data->len, E820_TYPE_RAM, E820_TYPE_RESERVED_KERN); + + if (data->type == SETUP_INDIRECT && + ((struct setup_indirect *)data->data)->type != SETUP_INDIRECT) { + e820__range_update(((struct setup_indirect *)data->data)->addr, + ((struct setup_indirect *)data->data)->len, + E820_TYPE_RAM, E820_TYPE_RESERVED_KERN); + e820__range_update_kexec(((struct setup_indirect *)data->data)->addr, + ((struct setup_indirect *)data->data)->len, + E820_TYPE_RAM, E820_TYPE_RESERVED_KERN); + } + pa_data = data->next; early_memunmap(data, sizeof(*data)); } diff --git a/arch/x86/kernel/kdebugfs.c b/arch/x86/kernel/kdebugfs.c index edaa30b20841..701a98300f86 100644 --- a/arch/x86/kernel/kdebugfs.c +++ b/arch/x86/kernel/kdebugfs.c @@ -44,7 +44,11 @@ static ssize_t setup_data_read(struct file *file, char __user *user_buf, if (count > node->len - pos) count = node->len - pos; - pa = node->paddr + sizeof(struct setup_data) + pos; + pa = node->paddr + pos; + + if (!(node->type & SETUP_INDIRECT) || node->type == SETUP_INDIRECT) + pa += sizeof(struct setup_data); + p = memremap(pa, count, MEMREMAP_WB); if (!p) return -ENOMEM; @@ -108,9 +112,17 @@ static int __init create_setup_data_nodes(struct dentry *parent) goto err_dir; } - node->paddr = pa_data; - node->type = data->type; - node->len = data->len; + if (data->type == SETUP_INDIRECT && + ((struct setup_indirect *)data->data)->type != SETUP_INDIRECT) { + node->paddr = ((struct setup_indirect *)data->data)->addr; + node->type = ((struct setup_indirect *)data->data)->type; + node->len = ((struct setup_indirect *)data->data)->len; + } else { + node->paddr = pa_data; + node->type = data->type; + node->len = data->len; + } + create_setup_data_node(d, no, node); pa_data = data->next; diff --git a/arch/x86/kernel/ksysfs.c b/arch/x86/kernel/ksysfs.c index 7969da939213..14ef8121aa53 100644 --- a/arch/x86/kernel/ksysfs.c +++ b/arch/x86/kernel/ksysfs.c @@ -100,7 +100,11 @@ static int __init get_setup_data_size(int nr, size_t *size) if (!data) return -ENOMEM; if (nr == i) { - *size = data->len; + if (data->type == SETUP_INDIRECT && + ((struct setup_indirect *)data->data)->type != SETUP_INDIRECT) + *size = ((struct setup_indirect *)data->data)->len; + else + *size = data->len; memunmap(data); return 0; } @@ -130,7 +134,10 @@ static ssize_t type_show(struct kobject *kobj, if (!data) return -ENOMEM; - ret = sprintf(buf, "0x%x\n", data->type); + if (data->type == SETUP_INDIRECT) + ret = sprintf(buf, "0x%x\n", ((struct setup_indirect *)data->data)->type); + else + ret = sprintf(buf, "0x%x\n", data->type); memunmap(data); return ret; } @@ -142,7 +149,7 @@ static ssize_t setup_data_data_read(struct file *fp, loff_t off, size_t count) { int nr, ret = 0; - u64 paddr; + u64 paddr, len; struct setup_data *data; void *p; @@ -157,19 +164,28 @@ static ssize_t setup_data_data_read(struct file *fp, if (!data) return -ENOMEM; - if (off > data->len) { + if (data->type == SETUP_INDIRECT && + ((struct setup_indirect *)data->data)->type != SETUP_INDIRECT) { + paddr = ((struct setup_indirect *)data->data)->addr; + len = ((struct setup_indirect *)data->data)->len; + } else { + paddr += sizeof(*data); + len = data->len; + } + + if (off > len) { ret = -EINVAL; goto out; } - if (count > data->len - off) - count = data->len - off; + if (count > len - off) + count = len - off; if (!count) goto out; ret = count; - p = memremap(paddr + sizeof(*data), data->len, MEMREMAP_WB); + p = memremap(paddr, len, MEMREMAP_WB); if (!p) { ret = -ENOMEM; goto out; diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c index 77ea96b794bd..4603702dbfc1 100644 --- a/arch/x86/kernel/setup.c +++ b/arch/x86/kernel/setup.c @@ -438,6 +438,10 @@ static void __init memblock_x86_reserve_range_setup_data(void) while (pa_data) { data = early_memremap(pa_data, sizeof(*data)); memblock_reserve(pa_data, sizeof(*data) + data->len); + if (data->type == SETUP_INDIRECT && + ((struct setup_indirect *)data->data)->type != SETUP_INDIRECT) + memblock_reserve(((struct setup_indirect *)data->data)->addr, + ((struct setup_indirect *)data->data)->len); pa_data = data->next; early_memunmap(data, sizeof(*data)); } diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c index a39dcdb5ae34..1ff9c2030b4f 100644 --- a/arch/x86/mm/ioremap.c +++ b/arch/x86/mm/ioremap.c @@ -626,6 +626,17 @@ static bool memremap_is_setup_data(resource_size_t phys_addr, paddr_next = data->next; len = data->len; + if ((phys_addr > paddr) && (phys_addr < (paddr + len))) { + memunmap(data); + return true; + } + + if (data->type == SETUP_INDIRECT && + ((struct setup_indirect *)data->data)->type != SETUP_INDIRECT) { + paddr = ((struct setup_indirect *)data->data)->addr; + len = ((struct setup_indirect *)data->data)->len; + } + memunmap(data); if ((phys_addr > paddr) && (phys_addr < (paddr + len))) -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.5 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8954CCA9EB5 for ; Mon, 4 Nov 2019 15:15:54 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 4E55B20842 for ; Mon, 4 Nov 2019 15:15:54 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=oracle.com header.i=@oracle.com header.b="pHnvkMlH" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4E55B20842 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=oracle.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iRe4y-00061E-FX; Mon, 04 Nov 2019 15:15:40 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iRe4x-000614-Ph for xen-devel@lists.xenproject.org; Mon, 04 Nov 2019 15:15:39 +0000 X-Inumbo-ID: f4d2db70-ff15-11e9-a181-12813bfff9fa Received: from aserp2120.oracle.com (unknown [141.146.126.78]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id f4d2db70-ff15-11e9-a181-12813bfff9fa; Mon, 04 Nov 2019 15:15:38 +0000 (UTC) Received: from pps.filterd (aserp2120.oracle.com [127.0.0.1]) by aserp2120.oracle.com (8.16.0.27/8.16.0.27) with SMTP id xA4FCP0v032260; Mon, 4 Nov 2019 15:14:32 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=from : to : cc : subject : date : message-id : in-reply-to : references; s=corp-2019-08-05; bh=85K7fC2AblLC2FOwgaSUFn+yoZ4NbAzwtxs7nqvsiEU=; b=pHnvkMlHIICf/ZFx5eq2Ya8tvOJZGaUne/n2aLj/2SkIj0yYG4TVVg5Az2Wjw6TTz4Rt 48f5ClSW+FIjxnh/DjMAVKfRFqInqksN9QDBFCeGhYnWHASGbjYqTv5YsmBdFB8ZFail L1RK3ZrNDGdHcTWgqBpDMAiSFPDDeJ8MLKh0LFELSwGUTgIS1hlIbz6ZgsXhLnW09MCY N62KOTtecuzzyiuNR1oIrSlJMHNe4zXY/Z25ueeU4FnHI1eUANRKnF2BjQPktn3AKwcX SQ6OAMtRuQ3GlQjkidUW4cyo92ZyTQUk1Sj8V6RVPjVrb++m3R2HiWx4V8CIj3HJpUXi 7w== Received: from aserp3030.oracle.com (aserp3030.oracle.com [141.146.126.71]) by aserp2120.oracle.com with ESMTP id 2w11rpr13u-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Mon, 04 Nov 2019 15:14:32 +0000 Received: from pps.filterd (aserp3030.oracle.com [127.0.0.1]) by aserp3030.oracle.com (8.16.0.27/8.16.0.27) with SMTP id xA4FABIi020092; Mon, 4 Nov 2019 15:14:32 GMT Received: from userv0121.oracle.com (userv0121.oracle.com [156.151.31.72]) by aserp3030.oracle.com with ESMTP id 2w1kxmhhg0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Mon, 04 Nov 2019 15:14:31 +0000 Received: from abhmp0015.oracle.com (abhmp0015.oracle.com [141.146.116.21]) by userv0121.oracle.com (8.14.4/8.13.8) with ESMTP id xA4FEUfo018320; Mon, 4 Nov 2019 15:14:30 GMT Received: from tomti.i.net-space.pl (/10.175.168.29) by default (Oracle Beehive Gateway v4.0) with ESMTP ; Mon, 04 Nov 2019 07:14:29 -0800 From: Daniel Kiper To: linux-efi@vger.kernel.org, linux-kernel@vger.kernel.org, x86@kernel.org, xen-devel@lists.xenproject.org Date: Mon, 4 Nov 2019 16:13:54 +0100 Message-Id: <20191104151354.28145-4-daniel.kiper@oracle.com> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20191104151354.28145-1-daniel.kiper@oracle.com> References: <20191104151354.28145-1-daniel.kiper@oracle.com> X-Proofpoint-Virus-Version: vendor=nai engine=6000 definitions=9431 signatures=668685 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=0 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 mlxscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1911040151 X-Proofpoint-Virus-Version: vendor=nai engine=6000 definitions=9431 signatures=668685 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 priorityscore=1501 malwarescore=0 suspectscore=0 phishscore=0 bulkscore=0 spamscore=0 clxscore=1015 lowpriorityscore=0 mlxscore=0 impostorscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1911040151 Subject: [Xen-devel] [PATCH v5 3/3] x86/boot: Introduce the setup_indirect X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: jgross@suse.com, eric.snowberg@oracle.com, ard.biesheuvel@linaro.org, konrad.wilk@oracle.com, corbet@lwn.net, peterz@infradead.org, ross.philipson@oracle.com, dave.hansen@linux.intel.com, mingo@redhat.com, bp@alien8.de, rdunlap@infradead.org, luto@kernel.org, hpa@zytor.com, kanth.ghatraju@oracle.com, boris.ostrovsky@oracle.com, tglx@linutronix.de MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" VGhlIHNldHVwX2RhdGEgaXMgYSBiaXQgYXdrd2FyZCB0byB1c2UgZm9yIGV4dHJlbWVseSBsYXJn ZSBkYXRhIG9iamVjdHMsCmJvdGggYmVjYXVzZSB0aGUgc2V0dXBfZGF0YSBoZWFkZXIgaGFzIHRv IGJlIGFkamFjZW50IHRvIHRoZSBkYXRhIG9iamVjdAphbmQgYmVjYXVzZSBpdCBoYXMgYSAzMi1i aXQgbGVuZ3RoIGZpZWxkLiBIb3dldmVyLCBpdCBpcyBpbXBvcnRhbnQgdGhhdAppbnRlcm1lZGlh dGUgc3RhZ2VzIG9mIHRoZSBib290IHByb2Nlc3MgaGF2ZSBhIHdheSB0byBpZGVudGlmeSB3aGlj aApjaHVua3Mgb2YgbWVtb3J5IGFyZSBvY2N1cGllZCBieSBrZXJuZWwgZGF0YS4gVGh1cyB3ZSBp bnRyb2R1Y2UgYW4gdW5pZm9ybQp3YXkgdG8gc3BlY2lmeSBzdWNoIGluZGlyZWN0IGRhdGEgYXMg c2V0dXBfaW5kaXJlY3Qgc3RydWN0IGFuZApTRVRVUF9JTkRJUkVDVCB0eXBlLgoKQW5kIGZpbmFs bHkgYnVtcCBzZXR1cF9oZWFkZXIgdmVyc2lvbiBpbiBhcmNoL3g4Ni9ib290L2hlYWRlci5TLgoK U3VnZ2VzdGVkLWJ5OiBILiBQZXRlciBBbnZpbiAoSW50ZWwpIDxocGFAenl0b3IuY29tPgpTaWdu ZWQtb2ZmLWJ5OiBEYW5pZWwgS2lwZXIgPGRhbmllbC5raXBlckBvcmFjbGUuY29tPgpBY2tlZC1i eTogS29ucmFkIFJ6ZXN6dXRlayBXaWxrIDxrb25yYWQud2lsa0BvcmFjbGUuY29tPgpSZXZpZXdl ZC1ieTogUm9zcyBQaGlsaXBzb24gPHJvc3MucGhpbGlwc29uQG9yYWNsZS5jb20+ClJldmlld2Vk LWJ5OiBILiBQZXRlciBBbnZpbiAoSW50ZWwpIDxocGFAenl0b3IuY29tPgotLS0KdjUgLSBzdWdn ZXN0aW9ucy9maXhlczoKICAgLSBidW1wIHNldHVwX2hlYWRlciB2ZXJzaW9uIGluIGFyY2gveDg2 L2Jvb3QvaGVhZGVyLlMKICAgICAoc3VnZ2VzdGVkIGJ5IEguIFBldGVyIEFudmluKS4KCnY0IC0g c3VnZ2VzdGlvbnMvZml4ZXM6CiAgIC0gY2hhbmdlICJOb3RlOiIgdG8gIi4uIG5vdGU6OiIuCgp2 MyAtIHN1Z2dlc3Rpb25zL2ZpeGVzOgogICAtIGFkZCBzZXR1cF9pbmRpcmVjdCBtYXBwaW5nL0tB U0xSIGF2b2lkYW5jZS9ldGMuIGNvZGUKICAgICAoc3VnZ2VzdGVkIGJ5IEguIFBldGVyIEFudmlu KSwKICAgLSB0aGUgU0VUVVBfSU5ESVJFQ1Qgc2V0cyBtb3N0IHNpZ25pZmljYW50IGJpdCByaWdo dCBub3c7CiAgICAgdGhpcyB3YXkgaXQgaXMgcG9zc2libGUgdG8gZGlmZmVyZW50aWF0ZSByZWd1 bGFyIHNldHVwX2RhdGEKICAgICBhbmQgc2V0dXBfaW5kaXJlY3Qgb2JqZWN0cyBpbiB0aGUgZGVi dWdmcyBmaWxlc3lzdGVtLgoKdjIgLSBzdWdnZXN0aW9ucy9maXhlczoKICAgLSBhZGQgc2V0dXBf aW5kaXJlY3QgdXNhZ2UgZXhhbXBsZQogICAgIChzdWdnZXN0ZWQgYnkgRXJpYyBTbm93YmVyZyBh bmQgUm9zcyBQaGlsaXBzb24pLgotLS0KIERvY3VtZW50YXRpb24veDg2L2Jvb3QucnN0ICAgICAg ICAgICAgIHwgNDMgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQogYXJjaC94ODYv Ym9vdC9jb21wcmVzc2VkL2thc2xyLmMgICAgICAgfCAxMiArKysrKysrKysrCiBhcmNoL3g4Ni9i b290L2NvbXByZXNzZWQva2VybmVsX2luZm8uUyB8ICAyICstCiBhcmNoL3g4Ni9ib290L2hlYWRl ci5TICAgICAgICAgICAgICAgICB8ICAyICstCiBhcmNoL3g4Ni9pbmNsdWRlL3VhcGkvYXNtL2Jv b3RwYXJhbS5oICB8IDE2ICsrKysrKysrKystLS0KIGFyY2gveDg2L2tlcm5lbC9lODIwLmMgICAg ICAgICAgICAgICAgIHwgMTEgKysrKysrKysrCiBhcmNoL3g4Ni9rZXJuZWwva2RlYnVnZnMuYyAg ICAgICAgICAgICB8IDIwICsrKysrKysrKysrKy0tLS0KIGFyY2gveDg2L2tlcm5lbC9rc3lzZnMu YyAgICAgICAgICAgICAgIHwgMzAgKysrKysrKysrKysrKysrKysrLS0tLS0tCiBhcmNoL3g4Ni9r ZXJuZWwvc2V0dXAuYyAgICAgICAgICAgICAgICB8ICA0ICsrKysKIGFyY2gveDg2L21tL2lvcmVt YXAuYyAgICAgICAgICAgICAgICAgIHwgMTEgKysrKysrKysrCiAxMCBmaWxlcyBjaGFuZ2VkLCAx MzQgaW5zZXJ0aW9ucygrKSwgMTcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRh dGlvbi94ODYvYm9vdC5yc3QgYi9Eb2N1bWVudGF0aW9uL3g4Ni9ib290LnJzdAppbmRleCAxZGFk NmVlZThhNWMuLjM4MTU1YmE4NzQwZiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi94ODYvYm9v dC5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi94ODYvYm9vdC5yc3QKQEAgLTgyNyw2ICs4MjcsNDcg QEAgUHJvdG9jb2w6CTIuMDkrCiAgIHN1cmUgdG8gY29uc2lkZXIgdGhlIGNhc2Ugd2hlcmUgdGhl IGxpbmtlZCBsaXN0IGFscmVhZHkgY29udGFpbnMKICAgZW50cmllcy4KIAorICBUaGUgc2V0dXBf ZGF0YSBpcyBhIGJpdCBhd2t3YXJkIHRvIHVzZSBmb3IgZXh0cmVtZWx5IGxhcmdlIGRhdGEgb2Jq ZWN0cywKKyAgYm90aCBiZWNhdXNlIHRoZSBzZXR1cF9kYXRhIGhlYWRlciBoYXMgdG8gYmUgYWRq YWNlbnQgdG8gdGhlIGRhdGEgb2JqZWN0CisgIGFuZCBiZWNhdXNlIGl0IGhhcyBhIDMyLWJpdCBs ZW5ndGggZmllbGQuIEhvd2V2ZXIsIGl0IGlzIGltcG9ydGFudCB0aGF0CisgIGludGVybWVkaWF0 ZSBzdGFnZXMgb2YgdGhlIGJvb3QgcHJvY2VzcyBoYXZlIGEgd2F5IHRvIGlkZW50aWZ5IHdoaWNo CisgIGNodW5rcyBvZiBtZW1vcnkgYXJlIG9jY3VwaWVkIGJ5IGtlcm5lbCBkYXRhLgorCisgIFRo dXMgc2V0dXBfaW5kaXJlY3Qgc3RydWN0IGFuZCBTRVRVUF9JTkRJUkVDVCB0eXBlIHdlcmUgaW50 cm9kdWNlZCBpbgorICBwcm90b2NvbCAyLjE1LgorCisgIHN0cnVjdCBzZXR1cF9pbmRpcmVjdCB7 CisgICAgX191MzIgdHlwZTsKKyAgICBfX3UzMiByZXNlcnZlZDsgIC8qIFJlc2VydmVkLCBtdXN0 IGJlIHNldCB0byB6ZXJvLiAqLworICAgIF9fdTY0IGxlbjsKKyAgICBfX3U2NCBhZGRyOworICB9 OworCisgIFRoZSB0eXBlIG1lbWJlciBpcyBhIFNFVFVQX0lORElSRUNUIHwgU0VUVVBfKiB0eXBl LiBIb3dldmVyLCBpdCBjYW5ub3QgYmUKKyAgU0VUVVBfSU5ESVJFQ1QgaXRzZWxmIHNpbmNlIG1h a2luZyB0aGUgc2V0dXBfaW5kaXJlY3QgYSB0cmVlIHN0cnVjdHVyZQorICBjb3VsZCByZXF1aXJl IGEgbG90IG9mIHN0YWNrIHNwYWNlIGluIHNvbWV0aGluZyB0aGF0IG5lZWRzIHRvIHBhcnNlIGl0 CisgIGFuZCBzdGFjayBzcGFjZSBjYW4gYmUgbGltaXRlZCBpbiBib290IGNvbnRleHRzLgorCisg IExldCdzIGdpdmUgYW4gZXhhbXBsZSBob3cgdG8gcG9pbnQgdG8gU0VUVVBfRTgyMF9FWFQgZGF0 YSB1c2luZyBzZXR1cF9pbmRpcmVjdC4KKyAgSW4gdGhpcyBjYXNlIHNldHVwX2RhdGEgYW5kIHNl dHVwX2luZGlyZWN0IHdpbGwgbG9vayBsaWtlIHRoaXM6CisKKyAgc3RydWN0IHNldHVwX2RhdGEg eworICAgIF9fdTY0IG5leHQgPSAwIG9yIDxhZGRyX29mX25leHRfc2V0dXBfZGF0YV9zdHJ1Y3Q+ OworICAgIF9fdTMyIHR5cGUgPSBTRVRVUF9JTkRJUkVDVDsKKyAgICBfX3UzMiBsZW4gPSBzaXpl b2Yoc2V0dXBfZGF0YSk7CisgICAgX191OCBkYXRhW3NpemVvZihzZXR1cF9pbmRpcmVjdCldID0g c3RydWN0IHNldHVwX2luZGlyZWN0IHsKKyAgICAgIF9fdTMyIHR5cGUgPSBTRVRVUF9JTkRJUkVD VCB8IFNFVFVQX0U4MjBfRVhUOworICAgICAgX191MzIgcmVzZXJ2ZWQgPSAwOworICAgICAgX191 NjQgbGVuID0gPGxlbl9vZl9TRVRVUF9FODIwX0VYVF9kYXRhPjsKKyAgICAgIF9fdTY0IGFkZHIg PSA8YWRkcl9vZl9TRVRVUF9FODIwX0VYVF9kYXRhPjsKKyAgICB9CisgIH0KKworLi4gbm90ZTo6 CisgICAgIFNFVFVQX0lORElSRUNUIHwgU0VUVVBfTk9ORSBvYmplY3RzIGNhbm5vdCBiZSBwcm9w ZXJseSBkaXN0aW5ndWlzaGVkCisgICAgIGZyb20gU0VUVVBfSU5ESVJFQ1QgaXRzZWxmLiBTbywg dGhpcyBraW5kIG9mIG9iamVjdHMgY2Fubm90IGJlIHByb3ZpZGVkCisgICAgIGJ5IHRoZSBib290 bG9hZGVycy4KKwogPT09PT09PT09PT09CT09PT09PT09PT09PQogRmllbGQgbmFtZToJcHJlZl9h ZGRyZXNzCiBUeXBlOgkJcmVhZCAocmVsb2MpCkBAIC05ODYsNyArMTAyNyw3IEBAIEZpZWxkIG5h bWU6CXNldHVwX3R5cGVfbWF4CiBPZmZzZXQvc2l6ZToJMHgwMDA4LzQKID09PT09PT09PT09PQk9 PT09PT09PT09PT09PQogCi0gIFRoaXMgZmllbGQgY29udGFpbnMgbWF4aW1hbCBhbGxvd2VkIHR5 cGUgZm9yIHNldHVwX2RhdGEuCisgIFRoaXMgZmllbGQgY29udGFpbnMgbWF4aW1hbCBhbGxvd2Vk IHR5cGUgZm9yIHNldHVwX2RhdGEgYW5kIHNldHVwX2luZGlyZWN0IHN0cnVjdHMuCiAKIAogVGhl IEltYWdlIENoZWNrc3VtCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQva2Fz bHIuYyBiL2FyY2gveDg2L2Jvb3QvY29tcHJlc3NlZC9rYXNsci5jCmluZGV4IDJlNTNjMDU2YmEy MC4uYmI5YmZlZjE3NGFlIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQva2Fz bHIuYworKysgYi9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQva2FzbHIuYwpAQCAtNDU5LDYgKzQ1 OSwxOCBAQCBzdGF0aWMgYm9vbCBtZW1fYXZvaWRfb3ZlcmxhcChzdHJ1Y3QgbWVtX3ZlY3RvciAq aW1nLAogCQkJaXNfb3ZlcmxhcHBpbmcgPSB0cnVlOwogCQl9CiAKKwkJaWYgKHB0ci0+dHlwZSA9 PSBTRVRVUF9JTkRJUkVDVCAmJgorCQkgICAgKChzdHJ1Y3Qgc2V0dXBfaW5kaXJlY3QgKilwdHIt PmRhdGEpLT50eXBlICE9IFNFVFVQX0lORElSRUNUKSB7CisJCQlhdm9pZC5zdGFydCA9ICgoc3Ry dWN0IHNldHVwX2luZGlyZWN0ICopcHRyLT5kYXRhKS0+YWRkcjsKKwkJCWF2b2lkLnNpemUgPSAo KHN0cnVjdCBzZXR1cF9pbmRpcmVjdCAqKXB0ci0+ZGF0YSktPmxlbjsKKworCQkJaWYgKG1lbV9v dmVybGFwcyhpbWcsICZhdm9pZCkgJiYgKGF2b2lkLnN0YXJ0IDwgZWFybGllc3QpKSB7CisJCQkJ Km92ZXJsYXAgPSBhdm9pZDsKKwkJCQllYXJsaWVzdCA9IG92ZXJsYXAtPnN0YXJ0OworCQkJCWlz X292ZXJsYXBwaW5nID0gdHJ1ZTsKKwkJCX0KKwkJfQorCiAJCXB0ciA9IChzdHJ1Y3Qgc2V0dXBf ZGF0YSAqKSh1bnNpZ25lZCBsb25nKXB0ci0+bmV4dDsKIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gv eDg2L2Jvb3QvY29tcHJlc3NlZC9rZXJuZWxfaW5mby5TIGIvYXJjaC94ODYvYm9vdC9jb21wcmVz c2VkL2tlcm5lbF9pbmZvLlMKaW5kZXggMDE4ZGFjYmQ3NTNlLi5mODE4ZWU4ZmJhMzggMTAwNjQ0 Ci0tLSBhL2FyY2gveDg2L2Jvb3QvY29tcHJlc3NlZC9rZXJuZWxfaW5mby5TCisrKyBiL2FyY2gv eDg2L2Jvb3QvY29tcHJlc3NlZC9rZXJuZWxfaW5mby5TCkBAIC0xNCw3ICsxNCw3IEBAIGtlcm5l bF9pbmZvOgogCS8qIFNpemUgdG90YWwuICovCiAJLmxvbmcJa2VybmVsX2luZm9fZW5kIC0ga2Vy bmVsX2luZm8KIAotCS8qIE1heGltYWwgYWxsb3dlZCB0eXBlIGZvciBzZXR1cF9kYXRhLiAqLwor CS8qIE1heGltYWwgYWxsb3dlZCB0eXBlIGZvciBzZXR1cF9kYXRhIGFuZCBzZXR1cF9pbmRpcmVj dCBzdHJ1Y3RzLiAqLwogCS5sb25nCVNFVFVQX1RZUEVfTUFYCiAKIGtlcm5lbF9pbmZvX3Zhcl9s ZW5fZGF0YToKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2Jvb3QvaGVhZGVyLlMgYi9hcmNoL3g4Ni9i b290L2hlYWRlci5TCmluZGV4IDIyZGNlY2FhYTg5OC4uOTdkOWI2ZDZjMWFmIDEwMDY0NAotLS0g YS9hcmNoL3g4Ni9ib290L2hlYWRlci5TCisrKyBiL2FyY2gveDg2L2Jvb3QvaGVhZGVyLlMKQEAg LTMwMCw3ICszMDAsNyBAQCBfc3RhcnQ6CiAJIyBQYXJ0IDIgb2YgdGhlIGhlYWRlciwgZnJvbSB0 aGUgb2xkIHNldHVwLlMKIAogCQkuYXNjaWkJIkhkclMiCQkjIGhlYWRlciBzaWduYXR1cmUKLQkJ LndvcmQJMHgwMjBkCQkjIGhlYWRlciB2ZXJzaW9uIG51bWJlciAoPj0gMHgwMTA1KQorCQkud29y ZAkweDAyMGYJCSMgaGVhZGVyIHZlcnNpb24gbnVtYmVyICg+PSAweDAxMDUpCiAJCQkJCSMgb3Ig ZWxzZSBvbGQgbG9hZGxpbi0xLjUgd2lsbCBmYWlsKQogCQkuZ2xvYmwgcmVhbG1vZGVfc3d0Y2gK IHJlYWxtb2RlX3N3dGNoOgkud29yZAkwLCAwCQkjIGRlZmF1bHRfc3dpdGNoLCBTRVRVUFNFRwpk aWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS91YXBpL2FzbS9ib290cGFyYW0uaCBiL2FyY2gv eDg2L2luY2x1ZGUvdWFwaS9hc20vYm9vdHBhcmFtLmgKaW5kZXggZGJiNDExMjhlNWEwLi45NDkw NjZiNTM5OGEgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvdWFwaS9hc20vYm9vdHBhcmFt LmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS91YXBpL2FzbS9ib290cGFyYW0uaApAQCAtMiw3ICsy LDcgQEAKICNpZm5kZWYgX0FTTV9YODZfQk9PVFBBUkFNX0gKICNkZWZpbmUgX0FTTV9YODZfQk9P VFBBUkFNX0gKIAotLyogc2V0dXBfZGF0YSB0eXBlcyAqLworLyogc2V0dXBfZGF0YS9zZXR1cF9p bmRpcmVjdCB0eXBlcyAqLwogI2RlZmluZSBTRVRVUF9OT05FCQkJMAogI2RlZmluZSBTRVRVUF9F ODIwX0VYVAkJCTEKICNkZWZpbmUgU0VUVVBfRFRCCQkJMgpAQCAtMTEsOCArMTEsMTAgQEAKICNk ZWZpbmUgU0VUVVBfQVBQTEVfUFJPUEVSVElFUwkJNQogI2RlZmluZSBTRVRVUF9KQUlMSE9VU0UJ CQk2CiAKLS8qIG1heChTRVRVUF8qKSAqLwotI2RlZmluZSBTRVRVUF9UWVBFX01BWAkJCVNFVFVQ X0pBSUxIT1VTRQorI2RlZmluZSBTRVRVUF9JTkRJUkVDVAkJCSgxPDwzMSkKKworLyogU0VUVVBf SU5ESVJFQ1QgfCBtYXgoU0VUVVBfKikgKi8KKyNkZWZpbmUgU0VUVVBfVFlQRV9NQVgJCQkoU0VU VVBfSU5ESVJFQ1QgfCBTRVRVUF9KQUlMSE9VU0UpCiAKIC8qIHJhbV9zaXplIGZsYWdzICovCiAj ZGVmaW5lIFJBTURJU0tfSU1BR0VfU1RBUlRfTUFTSwkweDA3RkYKQEAgLTUyLDYgKzU0LDE0IEBA IHN0cnVjdCBzZXR1cF9kYXRhIHsKIAlfX3U4IGRhdGFbMF07CiB9OwogCisvKiBleHRlbnNpYmxl IHNldHVwIGluZGlyZWN0IGRhdGEgbm9kZSAqLworc3RydWN0IHNldHVwX2luZGlyZWN0IHsKKwlf X3UzMiB0eXBlOworCV9fdTMyIHJlc2VydmVkOyAgLyogUmVzZXJ2ZWQsIG11c3QgYmUgc2V0IHRv IHplcm8uICovCisJX191NjQgbGVuOworCV9fdTY0IGFkZHI7Cit9OworCiBzdHJ1Y3Qgc2V0dXBf aGVhZGVyIHsKIAlfX3U4CXNldHVwX3NlY3RzOwogCV9fdTE2CXJvb3RfZmxhZ3M7CmRpZmYgLS1n aXQgYS9hcmNoL3g4Ni9rZXJuZWwvZTgyMC5jIGIvYXJjaC94ODYva2VybmVsL2U4MjAuYwppbmRl eCA3ZGEyYmNkMmI4ZWIuLjBiZmU5YTY4NWIzYiAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVs L2U4MjAuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvZTgyMC5jCkBAIC05OTksNiArOTk5LDE3IEBA IHZvaWQgX19pbml0IGU4MjBfX3Jlc2VydmVfc2V0dXBfZGF0YSh2b2lkKQogCQlkYXRhID0gZWFy bHlfbWVtcmVtYXAocGFfZGF0YSwgc2l6ZW9mKCpkYXRhKSk7CiAJCWU4MjBfX3JhbmdlX3VwZGF0 ZShwYV9kYXRhLCBzaXplb2YoKmRhdGEpK2RhdGEtPmxlbiwgRTgyMF9UWVBFX1JBTSwgRTgyMF9U WVBFX1JFU0VSVkVEX0tFUk4pOwogCQllODIwX19yYW5nZV91cGRhdGVfa2V4ZWMocGFfZGF0YSwg c2l6ZW9mKCpkYXRhKStkYXRhLT5sZW4sIEU4MjBfVFlQRV9SQU0sIEU4MjBfVFlQRV9SRVNFUlZF RF9LRVJOKTsKKworCQlpZiAoZGF0YS0+dHlwZSA9PSBTRVRVUF9JTkRJUkVDVCAmJgorCQkgICAg KChzdHJ1Y3Qgc2V0dXBfaW5kaXJlY3QgKilkYXRhLT5kYXRhKS0+dHlwZSAhPSBTRVRVUF9JTkRJ UkVDVCkgeworCQkJZTgyMF9fcmFuZ2VfdXBkYXRlKCgoc3RydWN0IHNldHVwX2luZGlyZWN0ICop ZGF0YS0+ZGF0YSktPmFkZHIsCisJCQkJCSAgICgoc3RydWN0IHNldHVwX2luZGlyZWN0ICopZGF0 YS0+ZGF0YSktPmxlbiwKKwkJCQkJICAgRTgyMF9UWVBFX1JBTSwgRTgyMF9UWVBFX1JFU0VSVkVE X0tFUk4pOworCQkJZTgyMF9fcmFuZ2VfdXBkYXRlX2tleGVjKCgoc3RydWN0IHNldHVwX2luZGly ZWN0ICopZGF0YS0+ZGF0YSktPmFkZHIsCisJCQkJCQkgKChzdHJ1Y3Qgc2V0dXBfaW5kaXJlY3Qg KilkYXRhLT5kYXRhKS0+bGVuLAorCQkJCQkJIEU4MjBfVFlQRV9SQU0sIEU4MjBfVFlQRV9SRVNF UlZFRF9LRVJOKTsKKwkJfQorCiAJCXBhX2RhdGEgPSBkYXRhLT5uZXh0OwogCQllYXJseV9tZW11 bm1hcChkYXRhLCBzaXplb2YoKmRhdGEpKTsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJu ZWwva2RlYnVnZnMuYyBiL2FyY2gveDg2L2tlcm5lbC9rZGVidWdmcy5jCmluZGV4IGVkYWEzMGIy MDg0MS4uNzAxYTk4MzAwZjg2IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwva2RlYnVnZnMu YworKysgYi9hcmNoL3g4Ni9rZXJuZWwva2RlYnVnZnMuYwpAQCAtNDQsNyArNDQsMTEgQEAgc3Rh dGljIHNzaXplX3Qgc2V0dXBfZGF0YV9yZWFkKHN0cnVjdCBmaWxlICpmaWxlLCBjaGFyIF9fdXNl ciAqdXNlcl9idWYsCiAJaWYgKGNvdW50ID4gbm9kZS0+bGVuIC0gcG9zKQogCQljb3VudCA9IG5v ZGUtPmxlbiAtIHBvczsKIAotCXBhID0gbm9kZS0+cGFkZHIgKyBzaXplb2Yoc3RydWN0IHNldHVw X2RhdGEpICsgcG9zOworCXBhID0gbm9kZS0+cGFkZHIgKyBwb3M7CisKKwlpZiAoIShub2RlLT50 eXBlICYgU0VUVVBfSU5ESVJFQ1QpIHx8IG5vZGUtPnR5cGUgPT0gU0VUVVBfSU5ESVJFQ1QpCisJ CXBhICs9IHNpemVvZihzdHJ1Y3Qgc2V0dXBfZGF0YSk7CisKIAlwID0gbWVtcmVtYXAocGEsIGNv dW50LCBNRU1SRU1BUF9XQik7CiAJaWYgKCFwKQogCQlyZXR1cm4gLUVOT01FTTsKQEAgLTEwOCw5 ICsxMTIsMTcgQEAgc3RhdGljIGludCBfX2luaXQgY3JlYXRlX3NldHVwX2RhdGFfbm9kZXMoc3Ry dWN0IGRlbnRyeSAqcGFyZW50KQogCQkJZ290byBlcnJfZGlyOwogCQl9CiAKLQkJbm9kZS0+cGFk ZHIgPSBwYV9kYXRhOwotCQlub2RlLT50eXBlID0gZGF0YS0+dHlwZTsKLQkJbm9kZS0+bGVuID0g ZGF0YS0+bGVuOworCQlpZiAoZGF0YS0+dHlwZSA9PSBTRVRVUF9JTkRJUkVDVCAmJgorCQkgICAg KChzdHJ1Y3Qgc2V0dXBfaW5kaXJlY3QgKilkYXRhLT5kYXRhKS0+dHlwZSAhPSBTRVRVUF9JTkRJ UkVDVCkgeworCQkJbm9kZS0+cGFkZHIgPSAoKHN0cnVjdCBzZXR1cF9pbmRpcmVjdCAqKWRhdGEt PmRhdGEpLT5hZGRyOworCQkJbm9kZS0+dHlwZSA9ICgoc3RydWN0IHNldHVwX2luZGlyZWN0ICop ZGF0YS0+ZGF0YSktPnR5cGU7CisJCQlub2RlLT5sZW4gPSAoKHN0cnVjdCBzZXR1cF9pbmRpcmVj dCAqKWRhdGEtPmRhdGEpLT5sZW47CisJCX0gZWxzZSB7CisJCQlub2RlLT5wYWRkciA9IHBhX2Rh dGE7CisJCQlub2RlLT50eXBlID0gZGF0YS0+dHlwZTsKKwkJCW5vZGUtPmxlbiA9IGRhdGEtPmxl bjsKKwkJfQorCiAJCWNyZWF0ZV9zZXR1cF9kYXRhX25vZGUoZCwgbm8sIG5vZGUpOwogCQlwYV9k YXRhID0gZGF0YS0+bmV4dDsKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2tzeXNmcy5j IGIvYXJjaC94ODYva2VybmVsL2tzeXNmcy5jCmluZGV4IDc5NjlkYTkzOTIxMy4uMTRlZjgxMjFh YTUzIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwva3N5c2ZzLmMKKysrIGIvYXJjaC94ODYv a2VybmVsL2tzeXNmcy5jCkBAIC0xMDAsNyArMTAwLDExIEBAIHN0YXRpYyBpbnQgX19pbml0IGdl dF9zZXR1cF9kYXRhX3NpemUoaW50IG5yLCBzaXplX3QgKnNpemUpCiAJCWlmICghZGF0YSkKIAkJ CXJldHVybiAtRU5PTUVNOwogCQlpZiAobnIgPT0gaSkgewotCQkJKnNpemUgPSBkYXRhLT5sZW47 CisJCQlpZiAoZGF0YS0+dHlwZSA9PSBTRVRVUF9JTkRJUkVDVCAmJgorCQkJICAgICgoc3RydWN0 IHNldHVwX2luZGlyZWN0ICopZGF0YS0+ZGF0YSktPnR5cGUgIT0gU0VUVVBfSU5ESVJFQ1QpCisJ CQkJKnNpemUgPSAoKHN0cnVjdCBzZXR1cF9pbmRpcmVjdCAqKWRhdGEtPmRhdGEpLT5sZW47CisJ CQllbHNlCisJCQkJKnNpemUgPSBkYXRhLT5sZW47CiAJCQltZW11bm1hcChkYXRhKTsKIAkJCXJl dHVybiAwOwogCQl9CkBAIC0xMzAsNyArMTM0LDEwIEBAIHN0YXRpYyBzc2l6ZV90IHR5cGVfc2hv dyhzdHJ1Y3Qga29iamVjdCAqa29iaiwKIAlpZiAoIWRhdGEpCiAJCXJldHVybiAtRU5PTUVNOwog Ci0JcmV0ID0gc3ByaW50ZihidWYsICIweCV4XG4iLCBkYXRhLT50eXBlKTsKKwlpZiAoZGF0YS0+ dHlwZSA9PSBTRVRVUF9JTkRJUkVDVCkKKwkJcmV0ID0gc3ByaW50ZihidWYsICIweCV4XG4iLCAo KHN0cnVjdCBzZXR1cF9pbmRpcmVjdCAqKWRhdGEtPmRhdGEpLT50eXBlKTsKKwllbHNlCisJCXJl dCA9IHNwcmludGYoYnVmLCAiMHgleFxuIiwgZGF0YS0+dHlwZSk7CiAJbWVtdW5tYXAoZGF0YSk7 CiAJcmV0dXJuIHJldDsKIH0KQEAgLTE0Miw3ICsxNDksNyBAQCBzdGF0aWMgc3NpemVfdCBzZXR1 cF9kYXRhX2RhdGFfcmVhZChzdHJ1Y3QgZmlsZSAqZnAsCiAJCQkJICAgIGxvZmZfdCBvZmYsIHNp emVfdCBjb3VudCkKIHsKIAlpbnQgbnIsIHJldCA9IDA7Ci0JdTY0IHBhZGRyOworCXU2NCBwYWRk ciwgbGVuOwogCXN0cnVjdCBzZXR1cF9kYXRhICpkYXRhOwogCXZvaWQgKnA7CiAKQEAgLTE1Nywx OSArMTY0LDI4IEBAIHN0YXRpYyBzc2l6ZV90IHNldHVwX2RhdGFfZGF0YV9yZWFkKHN0cnVjdCBm aWxlICpmcCwKIAlpZiAoIWRhdGEpCiAJCXJldHVybiAtRU5PTUVNOwogCi0JaWYgKG9mZiA+IGRh dGEtPmxlbikgeworCWlmIChkYXRhLT50eXBlID09IFNFVFVQX0lORElSRUNUICYmCisJICAgICgo c3RydWN0IHNldHVwX2luZGlyZWN0ICopZGF0YS0+ZGF0YSktPnR5cGUgIT0gU0VUVVBfSU5ESVJF Q1QpIHsKKwkJcGFkZHIgPSAoKHN0cnVjdCBzZXR1cF9pbmRpcmVjdCAqKWRhdGEtPmRhdGEpLT5h ZGRyOworCQlsZW4gPSAoKHN0cnVjdCBzZXR1cF9pbmRpcmVjdCAqKWRhdGEtPmRhdGEpLT5sZW47 CisJfSBlbHNlIHsKKwkJcGFkZHIgKz0gc2l6ZW9mKCpkYXRhKTsKKwkJbGVuID0gZGF0YS0+bGVu OworCX0KKworCWlmIChvZmYgPiBsZW4pIHsKIAkJcmV0ID0gLUVJTlZBTDsKIAkJZ290byBvdXQ7 CiAJfQogCi0JaWYgKGNvdW50ID4gZGF0YS0+bGVuIC0gb2ZmKQotCQljb3VudCA9IGRhdGEtPmxl biAtIG9mZjsKKwlpZiAoY291bnQgPiBsZW4gLSBvZmYpCisJCWNvdW50ID0gbGVuIC0gb2ZmOwog CiAJaWYgKCFjb3VudCkKIAkJZ290byBvdXQ7CiAKIAlyZXQgPSBjb3VudDsKLQlwID0gbWVtcmVt YXAocGFkZHIgKyBzaXplb2YoKmRhdGEpLCBkYXRhLT5sZW4sIE1FTVJFTUFQX1dCKTsKKwlwID0g bWVtcmVtYXAocGFkZHIsIGxlbiwgTUVNUkVNQVBfV0IpOwogCWlmICghcCkgewogCQlyZXQgPSAt RU5PTUVNOwogCQlnb3RvIG91dDsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9zZXR1cC5j IGIvYXJjaC94ODYva2VybmVsL3NldHVwLmMKaW5kZXggNzdlYTk2Yjc5NGJkLi40NjAzNzAyZGJm YzEgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9zZXR1cC5jCisrKyBiL2FyY2gveDg2L2tl cm5lbC9zZXR1cC5jCkBAIC00MzgsNiArNDM4LDEwIEBAIHN0YXRpYyB2b2lkIF9faW5pdCBtZW1i bG9ja194ODZfcmVzZXJ2ZV9yYW5nZV9zZXR1cF9kYXRhKHZvaWQpCiAJd2hpbGUgKHBhX2RhdGEp IHsKIAkJZGF0YSA9IGVhcmx5X21lbXJlbWFwKHBhX2RhdGEsIHNpemVvZigqZGF0YSkpOwogCQlt ZW1ibG9ja19yZXNlcnZlKHBhX2RhdGEsIHNpemVvZigqZGF0YSkgKyBkYXRhLT5sZW4pOworCQlp ZiAoZGF0YS0+dHlwZSA9PSBTRVRVUF9JTkRJUkVDVCAmJgorCQkgICAgKChzdHJ1Y3Qgc2V0dXBf aW5kaXJlY3QgKilkYXRhLT5kYXRhKS0+dHlwZSAhPSBTRVRVUF9JTkRJUkVDVCkKKwkJCW1lbWJs b2NrX3Jlc2VydmUoKChzdHJ1Y3Qgc2V0dXBfaW5kaXJlY3QgKilkYXRhLT5kYXRhKS0+YWRkciwK KwkJCQkJICgoc3RydWN0IHNldHVwX2luZGlyZWN0ICopZGF0YS0+ZGF0YSktPmxlbik7CiAJCXBh X2RhdGEgPSBkYXRhLT5uZXh0OwogCQllYXJseV9tZW11bm1hcChkYXRhLCBzaXplb2YoKmRhdGEp KTsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9tbS9pb3JlbWFwLmMgYi9hcmNoL3g4Ni9tbS9p b3JlbWFwLmMKaW5kZXggYTM5ZGNkYjVhZTM0Li4xZmY5YzIwMzBiNGYgMTAwNjQ0Ci0tLSBhL2Fy Y2gveDg2L21tL2lvcmVtYXAuYworKysgYi9hcmNoL3g4Ni9tbS9pb3JlbWFwLmMKQEAgLTYyNiw2 ICs2MjYsMTcgQEAgc3RhdGljIGJvb2wgbWVtcmVtYXBfaXNfc2V0dXBfZGF0YShyZXNvdXJjZV9z aXplX3QgcGh5c19hZGRyLAogCQlwYWRkcl9uZXh0ID0gZGF0YS0+bmV4dDsKIAkJbGVuID0gZGF0 YS0+bGVuOwogCisJCWlmICgocGh5c19hZGRyID4gcGFkZHIpICYmIChwaHlzX2FkZHIgPCAocGFk ZHIgKyBsZW4pKSkgeworCQkJbWVtdW5tYXAoZGF0YSk7CisJCQlyZXR1cm4gdHJ1ZTsKKwkJfQor CisJCWlmIChkYXRhLT50eXBlID09IFNFVFVQX0lORElSRUNUICYmCisJCSAgICAoKHN0cnVjdCBz ZXR1cF9pbmRpcmVjdCAqKWRhdGEtPmRhdGEpLT50eXBlICE9IFNFVFVQX0lORElSRUNUKSB7CisJ CQlwYWRkciA9ICgoc3RydWN0IHNldHVwX2luZGlyZWN0ICopZGF0YS0+ZGF0YSktPmFkZHI7CisJ CQlsZW4gPSAoKHN0cnVjdCBzZXR1cF9pbmRpcmVjdCAqKWRhdGEtPmRhdGEpLT5sZW47CisJCX0K KwogCQltZW11bm1hcChkYXRhKTsKIAogCQlpZiAoKHBoeXNfYWRkciA+IHBhZGRyKSAmJiAocGh5 c19hZGRyIDwgKHBhZGRyICsgbGVuKSkpCi0tIAoyLjExLjAKCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1k ZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qub3JnL21h aWxtYW4vbGlzdGluZm8veGVuLWRldmVs