From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dan Magenheimer Subject: [PATCH v7 1/2] hypervisor: XENMEM_claim_pages (subop of existing) hypercall Date: Mon, 26 Nov 2012 10:11:09 -0800 (PST) Message-ID: <07fd91ec-8b57-47d8-a44d-3b593de6bb9f@default> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="__135395347276233805abhmt116.oracle.com" Return-path: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org To: Jan Beulich , Keir Fraser , TimDeegan , Ian Campbell Cc: Andres Lagar-Cavilla , Zhigang Wang , Matthew Daley , Konrad Wilk , xen-devel@lists.xen.org List-Id: xen-devel@lists.xenproject.org --__135395347276233805abhmt116.oracle.com Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: quoted-printable (Note: After sufficient review, this is now a PATCH, not an RFC/PATCH) This is patch 1of2 of a seventh cut of the patch of the proposed XENMEM_claim_pages hypercall/subop, taking into account review feedback from Jan and Keir and IanC and Matthew Daley, plus some fixes found via runtime debugging (using printk and privcmd only). v6->v7: - Need co-existence with low_mem_virq [JBeulich] v5->v6: - Fix post-inc problem [mattjd] v4->v5: - Split tools part into separate patch [JBeulich] - Minor coding style fixups [JBeulich] - Use rcu_lock_domain_by_id, not _target version [JBeulich] v3->v4: (please ignore v3) - Process error, sent stale patch, sorry [djm] v2->v3: - Add per-domain and global "get" for unclaimed info [JBeulich] - New hypercall(s) should fail for unpriv callers [IanC] - Non-zero extent_order disallowed [JBeulich] - Remove bonehead ASSERTs [JBeulich] - Need not hold heaplock for decrease case too [JBeulich] - More descriptive failure return values [JBeulich] - Don't allow a claim to exceed max_pages [IanC] - Subops must be in correct ifdef block in memory.c [keir] v1->v2: - Add reset-to-zero page claim in domain_kill [JBeulich] - Proper handling of struct passed to hypercall [JBeulich] - Fix alloc_heap_pages when a domain has a claim [JBeulich] - Need not hold heap_lock if !d->unclaimed_pages [keir] - Fix missed tot_pages call in donate_page [djm] - Remove domain_reset_unclaimed_pages; use set with zero [djm] - Bugfixes found through testing in set_unclaimed [djm] - More comments in code [djm] - Code formatting fixes [djm] =3D=3D=3D Motivation: The goal of this hypercall is to attempt to atomically and very quickly determine if there are sufficient pages available in the system and, if so, "set aside" that quantity of pages for future allocations by that domain. Unlike an existing hypercall such as increase_reservation or populate_physmap, specific physical pageframes are not assigned to the domain because this cannot be done sufficiently quickly (especially for very large allocations in an arbitrarily fragmented system) and so the existing mechanisms result in classic time-of-check-time-of-use (TOCTOU) races. One can think of claiming as similar to a "lazy" allocation, but subsequent hypercalls are required to do the actual physical pageframe allocation. In order for a toolstack to "get" information about whether a domain has a claim and, if so, how large, and also for the toolstack to measure the total system-wide claim, a second subop has been added and exposed through domctl and libxl (see PATCH 2/2). Note that this patchset does not include a full toolstack implementation, in part because Oracle uses xm/xend and a proprietary toolstack and Citrix apparently does not plan to use the new mechanism. The following pseudo-code describes the proposed claim-based use model, which could easily be implemented as an xl option such as "xl create --claim". Current: - call populate_physmap repeatedly to achieve mem=3DN memory - if any populate_physmap call fails, report -ENOMEM up the stack - memory is held until domain dies or the toolstack decreases it Proposed: - call claim for mem=3DN amount of memory - if claim succeeds: call populate_physmap repeatedly to achieve mem=3DN memory (failsafe) else report -ENOMEM up the stack - claim is held until mem=3DN is achieved or the domain dies or the toolstack changes it to 0 - memory is held until domain dies or the toolstack decreases it It has been noted that this claim mechanism solves the underlying problem (slow failure of domain creation) for a large class of domains not not all, specifically not handling (but also not making the problem worse for) PV domains that specify the "superpages" flag, and 32-bit PV domains on large RAM systems. These may be addressed at a later time. Code overview: Though the hypercall simply does arithmetic within locks, some of the semantics in the code may be a bit subtle so let me explain a bit. The key variables (d->unclaimed_pages and total_unclaimed_pages) start at zero if no claim has yet been staked for any domain. (Perhaps a better name is "claimed_but_not_yet_possessed" but that's a bit unwieldy.) If no claim hypercalls are executed, there should be no impact on existing usage. When a claim is successfully staked by a domain, it is like a watermark but there is no record kept of the size of the claim. Instead, d->unclaimed_pages is set to the difference between d->tot_pages and the claim. When d->tot_pages increases or decreases, d->unclaimed_pages atomically decreases or increases. Once d->unclaimed_pages reaches zero, the claim is satisfied and d->unclaimed pages stays at zero -- unless a new claim is subsequently staked. The systemwide variable total_unclaimed_pages is always the sum of d->unclaimed_pages, across all domains. A non-domain- specific heap allocation will fail if total_unclaimed_pages exceeds free (plus, on tmem enabled systems, freeable) pages. Claim semantics may be modified by flags. The initial implementation has one flag, which discerns whether the caller would like tmem freeable pages to be considered in determining whether or not the claim can be successfully staked. Future flags may, for example, specify that the caller would like the claim to be successful only if there are sufficient pages available on a single node (per Dario's suggestion). A claim can be cancelled by requesting a claim of zero pages. A second subop returns the total outstanding claimed pages systemwide. Note: Save/restore/migrate may need to be modified, else it can be documented that all claims are cancelled. Signed-off-by: Dan Magenheimer arch/x86/mm.c | 2=20 arch/x86/mm/mem_sharing.c | 4 - common/domain.c | 1=20 common/domctl.c | 1=20 common/grant_table.c | 2=20 common/memory.c | 33 ++++++++++++ common/page_alloc.c | 120 +++++++++++++++++++++++++++++++++++++++++= +++-- include/public/domctl.h | 3 - include/public/memory.h | 39 ++++++++++++++ include/xen/mm.h | 7 ++ include/xen/sched.h | 1=20 11 files changed, 204 insertions(+), 9 deletions(-) diff --git a/xen/arch/x86/mm.c b/xen/arch/x86/mm.c index fad3d33..7e55908 100644 --- a/xen/arch/x86/mm.c +++ b/xen/arch/x86/mm.c @@ -3841,7 +3841,7 @@ int donate_page( { if ( d->tot_pages >=3D d->max_pages ) goto fail; - d->tot_pages++; + domain_increase_tot_pages(d, 1); } =20 page->count_info =3D PGC_allocated | 1; diff --git a/xen/arch/x86/mm/mem_sharing.c b/xen/arch/x86/mm/mem_sharing.c index 5103285..3d29e35 100644 --- a/xen/arch/x86/mm/mem_sharing.c +++ b/xen/arch/x86/mm/mem_sharing.c @@ -639,7 +639,7 @@ static int page_make_sharable(struct domain *d, } =20 page_set_owner(page, dom_cow); - d->tot_pages--; + domain_decrease_tot_pages(d, 1); drop_dom_ref =3D (d->tot_pages =3D=3D 0); page_list_del(page, &d->page_list); spin_unlock(&d->page_alloc_lock); @@ -680,7 +680,7 @@ static int page_make_private(struct domain *d, struct p= age_info *page) ASSERT(page_get_owner(page) =3D=3D dom_cow); page_set_owner(page, d); =20 - if ( d->tot_pages++ =3D=3D 0 ) + if ( domain_increase_tot_pages(d, 1) =3D=3D 1 ) get_domain(d); page_list_add_tail(page, &d->page_list); spin_unlock(&d->page_alloc_lock); diff --git a/xen/common/domain.c b/xen/common/domain.c index 12c8e24..f2cc4f5 100644 --- a/xen/common/domain.c +++ b/xen/common/domain.c @@ -492,6 +492,7 @@ int domain_kill(struct domain *d) evtchn_destroy(d); gnttab_release_mappings(d); tmem_destroy(d->tmem); + domain_set_unclaimed_pages(d, 0, 0); d->tmem =3D NULL; /* fallthrough */ case DOMDYING_dying: diff --git a/xen/common/domctl.c b/xen/common/domctl.c index a7a6b9f..e47a991 100644 --- a/xen/common/domctl.c +++ b/xen/common/domctl.c @@ -154,6 +154,7 @@ void getdomaininfo(struct domain *d, struct xen_domctl_= getdomaininfo *info) =20 info->tot_pages =3D d->tot_pages; info->max_pages =3D d->max_pages; + info->unclaimed_pages =3D d->unclaimed_pages; info->shr_pages =3D atomic_read(&d->shr_pages); info->paged_pages =3D atomic_read(&d->paged_pages); info->shared_info_frame =3D mfn_to_gmfn(d, __pa(d->shared_info)>>PAGE_= SHIFT); diff --git a/xen/common/grant_table.c b/xen/common/grant_table.c index 7912769..04bfda1 100644 --- a/xen/common/grant_table.c +++ b/xen/common/grant_table.c @@ -1656,7 +1656,7 @@ gnttab_transfer( } =20 /* Okay, add the page to 'e'. */ - if ( unlikely(e->tot_pages++ =3D=3D 0) ) + if ( unlikely(domain_increase_tot_pages(e, 1) =3D=3D 1) ) get_knownalive_domain(e); page_list_add_tail(page, &e->page_list); page_set_owner(page, e); diff --git a/xen/common/memory.c b/xen/common/memory.c index 83e2666..adb7581 100644 --- a/xen/common/memory.c +++ b/xen/common/memory.c @@ -454,7 +454,7 @@ static long memory_exchange(XEN_GUEST_HANDLE_PARAM(xen_= memory_exchange_t) arg) (j * (1UL << exch.out.extent_order))); =20 spin_lock(&d->page_alloc_lock); - d->tot_pages -=3D dec_count; + domain_decrease_tot_pages(d, dec_count); drop_dom_ref =3D (dec_count && !d->tot_pages); spin_unlock(&d->page_alloc_lock); =20 @@ -685,6 +685,37 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_= PARAM(void) arg) break; } =20 + case XENMEM_claim_pages: + if ( !IS_PRIV(current->domain) ) + return -EPERM; + + if ( copy_from_guest(&reservation, arg, 1) ) + return -EFAULT; + + if ( !guest_handle_is_null(reservation.extent_start) ) + return -EINVAL; + + if ( reservation.extent_order !=3D 0 ) + return -EINVAL; + + d =3D rcu_lock_domain_by_id(reservation.domid); + if ( d =3D=3D NULL ) + return -EINVAL; + + rc =3D domain_set_unclaimed_pages(d, reservation.nr_extents, + reservation.mem_flags); + + rcu_unlock_domain(d); + + break; + + case XENMEM_get_unclaimed_pages: + if ( !IS_PRIV(current->domain) ) + return -EPERM; + + rc =3D get_total_unclaimed_pages(); + break; + default: rc =3D arch_memory_op(op, arg); break; diff --git a/xen/common/page_alloc.c b/xen/common/page_alloc.c index 15ebc66..2fea9bf 100644 --- a/xen/common/page_alloc.c +++ b/xen/common/page_alloc.c @@ -238,6 +238,111 @@ static long midsize_alloc_zone_pages; #define MIDSIZE_ALLOC_FRAC 128 =20 static DEFINE_SPINLOCK(heap_lock); +static long total_unclaimed_pages; /* total outstanding claims by all doma= ins */ + +unsigned long domain_increase_tot_pages(struct domain *d, unsigned long pa= ges) +{ + long dom_before, dom_after, dom_claimed, sys_before, sys_after; + + ASSERT(spin_is_locked(&d->page_alloc_lock)); + if ( !d->unclaimed_pages ) + return d->tot_pages +=3D pages; + spin_lock(&heap_lock); + dom_before =3D d->unclaimed_pages; + dom_after =3D dom_before - pages; + if ( (dom_before > 0) && (dom_after < 0) ) + dom_claimed =3D 0; + else + dom_claimed =3D dom_after; + sys_before =3D total_unclaimed_pages; + sys_after =3D sys_before - (dom_before - dom_claimed); + BUG_ON( (sys_before > 0) && (sys_after < 0) ); + total_unclaimed_pages =3D sys_after; + d->unclaimed_pages =3D dom_claimed; + spin_unlock(&heap_lock); + return d->tot_pages; +} + +unsigned long domain_decrease_tot_pages(struct domain *d, unsigned long pa= ges) +{ + ASSERT(spin_is_locked(&d->page_alloc_lock)); + if ( !d->unclaimed_pages ) + return d->tot_pages -=3D pages; + + spin_lock(&heap_lock); + d->tot_pages -=3D pages; + d->unclaimed_pages +=3D pages; + total_unclaimed_pages +=3D pages; + spin_unlock(&heap_lock); + return d->tot_pages; +} + +int domain_set_unclaimed_pages(struct domain *d, unsigned long pages, + unsigned long flags) +{ + int ret =3D -ENOMEM; + unsigned long claim, avail_pages; + + /* + * take the domain's page_alloc_lock, else all increases/decreases + * must always take the global heap_lock rather than only in the much + * rarer case that d->unclaimed_pages is non-zero + */ + spin_lock(&d->page_alloc_lock); + spin_lock(&heap_lock); + + /* pages=3D=3D0 means "unset" the claim (and flags is ignored) */ + if ( pages =3D=3D 0 ) + { + total_unclaimed_pages -=3D d->unclaimed_pages; + d->unclaimed_pages =3D 0; + ret =3D 0; + goto out; + } + + /* only one active claim per domain please */ + if ( d->unclaimed_pages ) + { + ret =3D -EINVAL; + goto out; + } + + /* disallow a claim not exceeding current tot_pages or above max_pages= */ + if ( (pages <=3D d->tot_pages) || (pages > d->max_pages) ) + { + ret =3D -EINVAL; + goto out; + } + + /* how much memory is available? */ + avail_pages =3D total_avail_pages; + if ( !(flags & XENMEM_CLAIMF_free_only) ) + avail_pages +=3D tmem_freeable_pages(); + avail_pages -=3D total_unclaimed_pages; + + /* + * note, if domain has already allocated memory before making a claim= =20 + * then the claim must take tot_pages into account + */ + claim =3D pages - d->tot_pages; + if ( claim > avail_pages ) + goto out; + + /* yay, claim fits in available memory, stake the claim, success! */ + d->unclaimed_pages =3D claim; + total_unclaimed_pages +=3D d->unclaimed_pages; + ret =3D 0; + +out: + spin_unlock(&heap_lock); + spin_unlock(&d->page_alloc_lock); + return ret; +} + +long get_total_unclaimed_pages(void) +{ + return total_unclaimed_pages; +} =20 static unsigned long init_node_heap(int node, unsigned long mfn, unsigned long nr, bool_t *use_tail) @@ -374,7 +479,7 @@ static void __init setup_low_mem_virq(void) static void check_low_mem_virq(void) { unsigned long avail_pages =3D total_avail_pages + - (opt_tmem ? tmem_freeable_pages() : 0); + (opt_tmem ? tmem_freeable_pages() : 0) - total_unclaimed_pages; =20 if ( unlikely(avail_pages <=3D low_mem_virq_th) ) { @@ -443,6 +548,15 @@ static struct page_info *alloc_heap_pages( spin_lock(&heap_lock); =20 /* + * Claimed memory is considered unavailable unless the request + * is made by a domain with sufficient unclaimed pages. + */ + if ( (total_unclaimed_pages + request > + total_avail_pages + tmem_freeable_pages()) && + (d =3D=3D NULL || d->unclaimed_pages < request) ) + goto not_found; + + /* * TMEM: When available memory is scarce due to tmem absorbing it, all= ow * only mid-size allocations to avoid worst of fragmentation issues. * Others try tmem pools then fail. This is a workaround until all @@ -1291,7 +1405,7 @@ int assign_pages( if ( unlikely(d->tot_pages =3D=3D 0) ) get_knownalive_domain(d); =20 - d->tot_pages +=3D 1 << order; + domain_increase_tot_pages(d, 1 << order); } =20 for ( i =3D 0; i < (1 << order); i++ ) @@ -1375,7 +1489,7 @@ void free_domheap_pages(struct page_info *pg, unsigne= d int order) page_list_del2(&pg[i], &d->page_list, &d->arch.relmem_list); } =20 - d->tot_pages -=3D 1 << order; + domain_decrease_tot_pages(d, 1 << order); drop_dom_ref =3D (d->tot_pages =3D=3D 0); =20 spin_unlock_recursive(&d->page_alloc_lock); diff --git a/xen/include/public/domctl.h b/xen/include/public/domctl.h index 7c0f23d..5735c28 100644 --- a/xen/include/public/domctl.h +++ b/xen/include/public/domctl.h @@ -36,7 +36,7 @@ #include "grant_table.h" #include "hvm/save.h" =20 -#define XEN_DOMCTL_INTERFACE_VERSION 0x00000008 +#define XEN_DOMCTL_INTERFACE_VERSION 0x00000009 =20 /* * NB. xen_domctl.domain is an IN/OUT parameter for this operation. @@ -95,6 +95,7 @@ struct xen_domctl_getdomaininfo { uint32_t flags; /* XEN_DOMINF_* */ uint64_aligned_t tot_pages; uint64_aligned_t max_pages; + uint64_aligned_t unclaimed_pages; uint64_aligned_t shr_pages; uint64_aligned_t paged_pages; uint64_aligned_t shared_info_frame; /* GMFN of shared_info struct */ diff --git a/xen/include/public/memory.h b/xen/include/public/memory.h index f1ddbc0..15d6c72 100644 --- a/xen/include/public/memory.h +++ b/xen/include/public/memory.h @@ -68,6 +68,8 @@ struct xen_memory_reservation { * IN: GPFN bases of extents to populate with memory * OUT: GMFN bases of extents that were allocated * (NB. This command also updates the mach_to_phys translation table= ) + * XENMEM_claim_pages: + * IN: must be zero */ XEN_GUEST_HANDLE(xen_pfn_t) extent_start; =20 @@ -421,6 +423,43 @@ struct xen_mem_sharing_op { typedef struct xen_mem_sharing_op xen_mem_sharing_op_t; DEFINE_XEN_GUEST_HANDLE(xen_mem_sharing_op_t); =20 +/* + * Attempt to stake a claim for a domain on a quantity of pages + * of system RAM, but _not_ assign specific pageframes. Only + * arithmetic is performed so the hypercall is very fast and need + * not be preemptible, thus sidestepping time-of-check-time-of-use + * races for memory allocation. Returns 0 if the hypervisor page + * allocator has atomically and successfully claimed the requested + * number of pages, else non-zero. + * + * Any domain may have only one active claim. When sufficient memory + * has been allocated to resolve the claim, the claim silently expires. + * Claiming zero pages effectively resets any outstanding claim and + * is always successful. + * + * Note that a valid claim may be staked even after memory has been + * allocated for a domain. In this case, the claim is not incremental, + * i.e. if the domain's tot_pages is 3, and a claim is staked for 10, + * only 7 additional pages are claimed. + * + * Caller must be privileged or the hypercall fails. + */ +#define XENMEM_claim_pages 24 +/* + * XENMEM_claim_pages flags: + * free_only: claim is successful only if sufficient free pages + * are available. If not set and tmem is enabled, hypervisor + * may also consider tmem "freeable" pages to satisfy the claim. + */ +#define _XENMEM_CLAIMF_free_only 0 +#define XENMEM_CLAIMF_free_only (1U<<_XENMEM_CLAIMF_free_only) +/* + * Get the number of pages currently claimed (but not yet "possessed") + * across all domains. The caller must be privileged but otherwise + * the call never fails.=20 + */ +#define XENMEM_get_unclaimed_pages 25 + #endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */ =20 #endif /* __XEN_PUBLIC_MEMORY_H__ */ diff --git a/xen/include/xen/mm.h b/xen/include/xen/mm.h index 64a0cc1..b4dee92 100644 --- a/xen/include/xen/mm.h +++ b/xen/include/xen/mm.h @@ -48,6 +48,13 @@ void free_xenheap_pages(void *v, unsigned int order); #define alloc_xenheap_page() (alloc_xenheap_pages(0,0)) #define free_xenheap_page(v) (free_xenheap_pages(v,0)) =20 +/* Claim handling */ +unsigned long domain_increase_tot_pages(struct domain *d, unsigned long pa= ges); +unsigned long domain_decrease_tot_pages(struct domain *d, unsigned long pa= ges); +int domain_set_unclaimed_pages( + struct domain *d, unsigned long pages, unsigned long flags); +long get_total_unclaimed_pages(void); + /* Domain suballocator. These functions are *not* interrupt-safe.*/ void init_domheap_pages(paddr_t ps, paddr_t pe); struct page_info *alloc_domheap_pages( diff --git a/xen/include/xen/sched.h b/xen/include/xen/sched.h index 6c55039..480ef39 100644 --- a/xen/include/xen/sched.h +++ b/xen/include/xen/sched.h @@ -242,6 +242,7 @@ struct domain struct page_list_head page_list; /* linked list */ struct page_list_head xenpage_list; /* linked list (size xenheap_pages= ) */ unsigned int tot_pages; /* number of pages currently possese= d */ + unsigned int unclaimed_pages; /* pages claimed but not possessed = */ unsigned int max_pages; /* maximum value for tot_pages = */ atomic_t shr_pages; /* number of shared pages = */ atomic_t paged_pages; /* number of paged-out pages = */ --__135395347276233805abhmt116.oracle.com Content-Type: application/octet-stream; name="claim-121126-hyp.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="claim-121126-hyp.patch" ZGlmZiAtLWdpdCBhL3hlbi9hcmNoL3g4Ni9tbS5jIGIveGVuL2FyY2gveDg2L21tLmMKaW5kZXgg ZmFkM2QzMy4uN2U1NTkwOCAxMDA2NDQKLS0tIGEveGVuL2FyY2gveDg2L21tLmMKKysrIGIveGVu L2FyY2gveDg2L21tLmMKQEAgLTM4NDEsNyArMzg0MSw3IEBAIGludCBkb25hdGVfcGFnZSgKICAg ICB7CiAgICAgICAgIGlmICggZC0+dG90X3BhZ2VzID49IGQtPm1heF9wYWdlcyApCiAgICAgICAg ICAgICBnb3RvIGZhaWw7Ci0gICAgICAgIGQtPnRvdF9wYWdlcysrOworICAgICAgICBkb21haW5f aW5jcmVhc2VfdG90X3BhZ2VzKGQsIDEpOwogICAgIH0KIAogICAgIHBhZ2UtPmNvdW50X2luZm8g PSBQR0NfYWxsb2NhdGVkIHwgMTsKZGlmZiAtLWdpdCBhL3hlbi9hcmNoL3g4Ni9tbS9tZW1fc2hh cmluZy5jIGIveGVuL2FyY2gveDg2L21tL21lbV9zaGFyaW5nLmMKaW5kZXggNTEwMzI4NS4uM2Qy OWUzNSAxMDA2NDQKLS0tIGEveGVuL2FyY2gveDg2L21tL21lbV9zaGFyaW5nLmMKKysrIGIveGVu L2FyY2gveDg2L21tL21lbV9zaGFyaW5nLmMKQEAgLTYzOSw3ICs2MzksNyBAQCBzdGF0aWMgaW50 IHBhZ2VfbWFrZV9zaGFyYWJsZShzdHJ1Y3QgZG9tYWluICpkLAogICAgIH0KIAogICAgIHBhZ2Vf c2V0X293bmVyKHBhZ2UsIGRvbV9jb3cpOwotICAgIGQtPnRvdF9wYWdlcy0tOworICAgIGRvbWFp bl9kZWNyZWFzZV90b3RfcGFnZXMoZCwgMSk7CiAgICAgZHJvcF9kb21fcmVmID0gKGQtPnRvdF9w YWdlcyA9PSAwKTsKICAgICBwYWdlX2xpc3RfZGVsKHBhZ2UsICZkLT5wYWdlX2xpc3QpOwogICAg IHNwaW5fdW5sb2NrKCZkLT5wYWdlX2FsbG9jX2xvY2spOwpAQCAtNjgwLDcgKzY4MCw3IEBAIHN0 YXRpYyBpbnQgcGFnZV9tYWtlX3ByaXZhdGUoc3RydWN0IGRvbWFpbiAqZCwgc3RydWN0IHBhZ2Vf aW5mbyAqcGFnZSkKICAgICBBU1NFUlQocGFnZV9nZXRfb3duZXIocGFnZSkgPT0gZG9tX2Nvdyk7 CiAgICAgcGFnZV9zZXRfb3duZXIocGFnZSwgZCk7CiAKLSAgICBpZiAoIGQtPnRvdF9wYWdlcysr ID09IDAgKQorICAgIGlmICggZG9tYWluX2luY3JlYXNlX3RvdF9wYWdlcyhkLCAxKSA9PSAxICkK ICAgICAgICAgZ2V0X2RvbWFpbihkKTsKICAgICBwYWdlX2xpc3RfYWRkX3RhaWwocGFnZSwgJmQt PnBhZ2VfbGlzdCk7CiAgICAgc3Bpbl91bmxvY2soJmQtPnBhZ2VfYWxsb2NfbG9jayk7CmRpZmYg LS1naXQgYS94ZW4vY29tbW9uL2RvbWFpbi5jIGIveGVuL2NvbW1vbi9kb21haW4uYwppbmRleCAx MmM4ZTI0Li5mMmNjNGY1IDEwMDY0NAotLS0gYS94ZW4vY29tbW9uL2RvbWFpbi5jCisrKyBiL3hl bi9jb21tb24vZG9tYWluLmMKQEAgLTQ5Miw2ICs0OTIsNyBAQCBpbnQgZG9tYWluX2tpbGwoc3Ry dWN0IGRvbWFpbiAqZCkKICAgICAgICAgZXZ0Y2huX2Rlc3Ryb3koZCk7CiAgICAgICAgIGdudHRh Yl9yZWxlYXNlX21hcHBpbmdzKGQpOwogICAgICAgICB0bWVtX2Rlc3Ryb3koZC0+dG1lbSk7Cisg ICAgICAgIGRvbWFpbl9zZXRfdW5jbGFpbWVkX3BhZ2VzKGQsIDAsIDApOwogICAgICAgICBkLT50 bWVtID0gTlVMTDsKICAgICAgICAgLyogZmFsbHRocm91Z2ggKi8KICAgICBjYXNlIERPTURZSU5H X2R5aW5nOgpkaWZmIC0tZ2l0IGEveGVuL2NvbW1vbi9kb21jdGwuYyBiL3hlbi9jb21tb24vZG9t Y3RsLmMKaW5kZXggYTdhNmI5Zi4uZTQ3YTk5MSAxMDA2NDQKLS0tIGEveGVuL2NvbW1vbi9kb21j dGwuYworKysgYi94ZW4vY29tbW9uL2RvbWN0bC5jCkBAIC0xNTQsNiArMTU0LDcgQEAgdm9pZCBn ZXRkb21haW5pbmZvKHN0cnVjdCBkb21haW4gKmQsIHN0cnVjdCB4ZW5fZG9tY3RsX2dldGRvbWFp bmluZm8gKmluZm8pCiAKICAgICBpbmZvLT50b3RfcGFnZXMgICAgICAgICA9IGQtPnRvdF9wYWdl czsKICAgICBpbmZvLT5tYXhfcGFnZXMgICAgICAgICA9IGQtPm1heF9wYWdlczsKKyAgICBpbmZv LT51bmNsYWltZWRfcGFnZXMgICA9IGQtPnVuY2xhaW1lZF9wYWdlczsKICAgICBpbmZvLT5zaHJf cGFnZXMgICAgICAgICA9IGF0b21pY19yZWFkKCZkLT5zaHJfcGFnZXMpOwogICAgIGluZm8tPnBh Z2VkX3BhZ2VzICAgICAgID0gYXRvbWljX3JlYWQoJmQtPnBhZ2VkX3BhZ2VzKTsKICAgICBpbmZv LT5zaGFyZWRfaW5mb19mcmFtZSA9IG1mbl90b19nbWZuKGQsIF9fcGEoZC0+c2hhcmVkX2luZm8p Pj5QQUdFX1NISUZUKTsKZGlmZiAtLWdpdCBhL3hlbi9jb21tb24vZ3JhbnRfdGFibGUuYyBiL3hl bi9jb21tb24vZ3JhbnRfdGFibGUuYwppbmRleCA3OTEyNzY5Li4wNGJmZGExIDEwMDY0NAotLS0g YS94ZW4vY29tbW9uL2dyYW50X3RhYmxlLmMKKysrIGIveGVuL2NvbW1vbi9ncmFudF90YWJsZS5j CkBAIC0xNjU2LDcgKzE2NTYsNyBAQCBnbnR0YWJfdHJhbnNmZXIoCiAgICAgICAgIH0KIAogICAg ICAgICAvKiBPa2F5LCBhZGQgdGhlIHBhZ2UgdG8gJ2UnLiAqLwotICAgICAgICBpZiAoIHVubGlr ZWx5KGUtPnRvdF9wYWdlcysrID09IDApICkKKyAgICAgICAgaWYgKCB1bmxpa2VseShkb21haW5f aW5jcmVhc2VfdG90X3BhZ2VzKGUsIDEpID09IDEpICkKICAgICAgICAgICAgIGdldF9rbm93bmFs aXZlX2RvbWFpbihlKTsKICAgICAgICAgcGFnZV9saXN0X2FkZF90YWlsKHBhZ2UsICZlLT5wYWdl X2xpc3QpOwogICAgICAgICBwYWdlX3NldF9vd25lcihwYWdlLCBlKTsKZGlmZiAtLWdpdCBhL3hl bi9jb21tb24vbWVtb3J5LmMgYi94ZW4vY29tbW9uL21lbW9yeS5jCmluZGV4IDgzZTI2NjYuLmFk Yjc1ODEgMTAwNjQ0Ci0tLSBhL3hlbi9jb21tb24vbWVtb3J5LmMKKysrIGIveGVuL2NvbW1vbi9t ZW1vcnkuYwpAQCAtNDU0LDcgKzQ1NCw3IEBAIHN0YXRpYyBsb25nIG1lbW9yeV9leGNoYW5nZShY RU5fR1VFU1RfSEFORExFX1BBUkFNKHhlbl9tZW1vcnlfZXhjaGFuZ2VfdCkgYXJnKQogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAoaiAqICgxVUwgPDwgZXhjaC5vdXQuZXh0ZW50X29yZGVy KSkpOwogCiAgICAgICAgICAgICAgICAgc3Bpbl9sb2NrKCZkLT5wYWdlX2FsbG9jX2xvY2spOwot ICAgICAgICAgICAgICAgIGQtPnRvdF9wYWdlcyAtPSBkZWNfY291bnQ7CisgICAgICAgICAgICAg ICAgZG9tYWluX2RlY3JlYXNlX3RvdF9wYWdlcyhkLCBkZWNfY291bnQpOwogICAgICAgICAgICAg ICAgIGRyb3BfZG9tX3JlZiA9IChkZWNfY291bnQgJiYgIWQtPnRvdF9wYWdlcyk7CiAgICAgICAg ICAgICAgICAgc3Bpbl91bmxvY2soJmQtPnBhZ2VfYWxsb2NfbG9jayk7CiAKQEAgLTY4NSw2ICs2 ODUsMzcgQEAgbG9uZyBkb19tZW1vcnlfb3AodW5zaWduZWQgbG9uZyBjbWQsIFhFTl9HVUVTVF9I QU5ETEVfUEFSQU0odm9pZCkgYXJnKQogICAgICAgICBicmVhazsKICAgICB9CiAKKyAgICBjYXNl IFhFTk1FTV9jbGFpbV9wYWdlczoKKyAgICAgICAgaWYgKCAhSVNfUFJJVihjdXJyZW50LT5kb21h aW4pICkKKyAgICAgICAgICAgIHJldHVybiAtRVBFUk07CisKKyAgICAgICAgaWYgKCBjb3B5X2Zy b21fZ3Vlc3QoJnJlc2VydmF0aW9uLCBhcmcsIDEpICkKKyAgICAgICAgICAgIHJldHVybiAtRUZB VUxUOworCisgICAgICAgIGlmICggIWd1ZXN0X2hhbmRsZV9pc19udWxsKHJlc2VydmF0aW9uLmV4 dGVudF9zdGFydCkgKQorICAgICAgICAgICAgcmV0dXJuIC1FSU5WQUw7CisKKyAgICAgICAgaWYg KCByZXNlcnZhdGlvbi5leHRlbnRfb3JkZXIgIT0gMCApCisgICAgICAgICAgICByZXR1cm4gLUVJ TlZBTDsKKworICAgICAgICBkID0gcmN1X2xvY2tfZG9tYWluX2J5X2lkKHJlc2VydmF0aW9uLmRv bWlkKTsKKyAgICAgICAgaWYgKCBkID09IE5VTEwgKQorICAgICAgICAgICAgcmV0dXJuIC1FSU5W QUw7CisKKyAgICAgICAgcmMgPSBkb21haW5fc2V0X3VuY2xhaW1lZF9wYWdlcyhkLCByZXNlcnZh dGlvbi5ucl9leHRlbnRzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJlc2VydmF0aW9uLm1lbV9mbGFncyk7CisKKyAgICAgICAgcmN1X3VubG9ja19kb21haW4oZCk7 CisKKyAgICAgICAgYnJlYWs7CisKKyAgICBjYXNlIFhFTk1FTV9nZXRfdW5jbGFpbWVkX3BhZ2Vz OgorICAgICAgICBpZiAoICFJU19QUklWKGN1cnJlbnQtPmRvbWFpbikgKQorICAgICAgICAgICAg cmV0dXJuIC1FUEVSTTsKKworICAgICAgICByYyA9IGdldF90b3RhbF91bmNsYWltZWRfcGFnZXMo KTsKKyAgICAgICAgYnJlYWs7CisKICAgICBkZWZhdWx0OgogICAgICAgICByYyA9IGFyY2hfbWVt b3J5X29wKG9wLCBhcmcpOwogICAgICAgICBicmVhazsKZGlmZiAtLWdpdCBhL3hlbi9jb21tb24v cGFnZV9hbGxvYy5jIGIveGVuL2NvbW1vbi9wYWdlX2FsbG9jLmMKaW5kZXggMTVlYmM2Ni4uMmZl YTliZiAxMDA2NDQKLS0tIGEveGVuL2NvbW1vbi9wYWdlX2FsbG9jLmMKKysrIGIveGVuL2NvbW1v bi9wYWdlX2FsbG9jLmMKQEAgLTIzOCw2ICsyMzgsMTExIEBAIHN0YXRpYyBsb25nIG1pZHNpemVf YWxsb2Nfem9uZV9wYWdlczsKICNkZWZpbmUgTUlEU0laRV9BTExPQ19GUkFDIDEyOAogCiBzdGF0 aWMgREVGSU5FX1NQSU5MT0NLKGhlYXBfbG9jayk7CitzdGF0aWMgbG9uZyB0b3RhbF91bmNsYWlt ZWRfcGFnZXM7IC8qIHRvdGFsIG91dHN0YW5kaW5nIGNsYWltcyBieSBhbGwgZG9tYWlucyAqLwor Cit1bnNpZ25lZCBsb25nIGRvbWFpbl9pbmNyZWFzZV90b3RfcGFnZXMoc3RydWN0IGRvbWFpbiAq ZCwgdW5zaWduZWQgbG9uZyBwYWdlcykKK3sKKyAgICBsb25nIGRvbV9iZWZvcmUsIGRvbV9hZnRl ciwgZG9tX2NsYWltZWQsIHN5c19iZWZvcmUsIHN5c19hZnRlcjsKKworICAgIEFTU0VSVChzcGlu X2lzX2xvY2tlZCgmZC0+cGFnZV9hbGxvY19sb2NrKSk7CisgICAgaWYgKCAhZC0+dW5jbGFpbWVk X3BhZ2VzICkKKyAgICAgICAgcmV0dXJuIGQtPnRvdF9wYWdlcyArPSBwYWdlczsKKyAgICBzcGlu X2xvY2soJmhlYXBfbG9jayk7CisgICAgZG9tX2JlZm9yZSA9IGQtPnVuY2xhaW1lZF9wYWdlczsK KyAgICBkb21fYWZ0ZXIgPSBkb21fYmVmb3JlIC0gcGFnZXM7CisgICAgaWYgKCAoZG9tX2JlZm9y ZSA+IDApICYmIChkb21fYWZ0ZXIgPCAwKSApCisgICAgICAgIGRvbV9jbGFpbWVkID0gMDsKKyAg ICBlbHNlCisgICAgICAgIGRvbV9jbGFpbWVkID0gZG9tX2FmdGVyOworICAgIHN5c19iZWZvcmUg PSB0b3RhbF91bmNsYWltZWRfcGFnZXM7CisgICAgc3lzX2FmdGVyID0gc3lzX2JlZm9yZSAtIChk b21fYmVmb3JlIC0gZG9tX2NsYWltZWQpOworICAgIEJVR19PTiggKHN5c19iZWZvcmUgPiAwKSAm JiAoc3lzX2FmdGVyIDwgMCkgKTsKKyAgICB0b3RhbF91bmNsYWltZWRfcGFnZXMgPSBzeXNfYWZ0 ZXI7CisgICAgZC0+dW5jbGFpbWVkX3BhZ2VzID0gZG9tX2NsYWltZWQ7CisgICAgc3Bpbl91bmxv Y2soJmhlYXBfbG9jayk7CisgICAgcmV0dXJuIGQtPnRvdF9wYWdlczsKK30KKwordW5zaWduZWQg bG9uZyBkb21haW5fZGVjcmVhc2VfdG90X3BhZ2VzKHN0cnVjdCBkb21haW4gKmQsIHVuc2lnbmVk IGxvbmcgcGFnZXMpCit7CisgICAgQVNTRVJUKHNwaW5faXNfbG9ja2VkKCZkLT5wYWdlX2FsbG9j X2xvY2spKTsKKyAgICBpZiAoICFkLT51bmNsYWltZWRfcGFnZXMgKQorICAgICAgICByZXR1cm4g ZC0+dG90X3BhZ2VzIC09IHBhZ2VzOworCisgICAgc3Bpbl9sb2NrKCZoZWFwX2xvY2spOworICAg IGQtPnRvdF9wYWdlcyAtPSBwYWdlczsKKyAgICBkLT51bmNsYWltZWRfcGFnZXMgKz0gcGFnZXM7 CisgICAgdG90YWxfdW5jbGFpbWVkX3BhZ2VzICs9IHBhZ2VzOworICAgIHNwaW5fdW5sb2NrKCZo ZWFwX2xvY2spOworICAgIHJldHVybiBkLT50b3RfcGFnZXM7Cit9CisKK2ludCBkb21haW5fc2V0 X3VuY2xhaW1lZF9wYWdlcyhzdHJ1Y3QgZG9tYWluICpkLCB1bnNpZ25lZCBsb25nIHBhZ2VzLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBsb25nIGZsYWdzKQorewor ICAgIGludCByZXQgPSAtRU5PTUVNOworICAgIHVuc2lnbmVkIGxvbmcgY2xhaW0sIGF2YWlsX3Bh Z2VzOworCisgICAgLyoKKyAgICAgKiB0YWtlIHRoZSBkb21haW4ncyBwYWdlX2FsbG9jX2xvY2ss IGVsc2UgYWxsIGluY3JlYXNlcy9kZWNyZWFzZXMKKyAgICAgKiBtdXN0IGFsd2F5cyB0YWtlIHRo ZSBnbG9iYWwgaGVhcF9sb2NrIHJhdGhlciB0aGFuIG9ubHkgaW4gdGhlIG11Y2gKKyAgICAgKiBy YXJlciBjYXNlIHRoYXQgZC0+dW5jbGFpbWVkX3BhZ2VzIGlzIG5vbi16ZXJvCisgICAgICovCisg ICAgc3Bpbl9sb2NrKCZkLT5wYWdlX2FsbG9jX2xvY2spOworICAgIHNwaW5fbG9jaygmaGVhcF9s b2NrKTsKKworICAgIC8qIHBhZ2VzPT0wIG1lYW5zICJ1bnNldCIgdGhlIGNsYWltIChhbmQgZmxh Z3MgaXMgaWdub3JlZCkgKi8KKyAgICBpZiAoIHBhZ2VzID09IDAgKQorICAgIHsKKyAgICAgICAg dG90YWxfdW5jbGFpbWVkX3BhZ2VzIC09IGQtPnVuY2xhaW1lZF9wYWdlczsKKyAgICAgICAgZC0+ dW5jbGFpbWVkX3BhZ2VzID0gMDsKKyAgICAgICAgcmV0ID0gMDsKKyAgICAgICAgZ290byBvdXQ7 CisgICAgfQorCisgICAgLyogb25seSBvbmUgYWN0aXZlIGNsYWltIHBlciBkb21haW4gcGxlYXNl ICovCisgICAgaWYgKCBkLT51bmNsYWltZWRfcGFnZXMgKQorICAgIHsKKyAgICAgICAgcmV0ID0g LUVJTlZBTDsKKyAgICAgICAgZ290byBvdXQ7CisgICAgfQorCisgICAgLyogZGlzYWxsb3cgYSBj bGFpbSBub3QgZXhjZWVkaW5nIGN1cnJlbnQgdG90X3BhZ2VzIG9yIGFib3ZlIG1heF9wYWdlcyAq LworICAgIGlmICggKHBhZ2VzIDw9IGQtPnRvdF9wYWdlcykgfHwgKHBhZ2VzID4gZC0+bWF4X3Bh Z2VzKSApCisgICAgeworICAgICAgICByZXQgPSAtRUlOVkFMOworICAgICAgICBnb3RvIG91dDsK KyAgICB9CisKKyAgICAvKiBob3cgbXVjaCBtZW1vcnkgaXMgYXZhaWxhYmxlPyAqLworICAgIGF2 YWlsX3BhZ2VzID0gdG90YWxfYXZhaWxfcGFnZXM7CisgICAgaWYgKCAhKGZsYWdzICYgWEVOTUVN X0NMQUlNRl9mcmVlX29ubHkpICkKKyAgICAgICAgYXZhaWxfcGFnZXMgKz0gdG1lbV9mcmVlYWJs ZV9wYWdlcygpOworICAgIGF2YWlsX3BhZ2VzIC09IHRvdGFsX3VuY2xhaW1lZF9wYWdlczsKKwor ICAgIC8qCisgICAgICogbm90ZSwgaWYgZG9tYWluIGhhcyBhbHJlYWR5IGFsbG9jYXRlZCBtZW1v cnkgYmVmb3JlIG1ha2luZyBhIGNsYWltIAorICAgICAqIHRoZW4gdGhlIGNsYWltIG11c3QgdGFr ZSB0b3RfcGFnZXMgaW50byBhY2NvdW50CisgICAgICovCisgICAgY2xhaW0gPSBwYWdlcyAtIGQt PnRvdF9wYWdlczsKKyAgICBpZiAoIGNsYWltID4gYXZhaWxfcGFnZXMgKQorICAgICAgICBnb3Rv IG91dDsKKworICAgIC8qIHlheSwgY2xhaW0gZml0cyBpbiBhdmFpbGFibGUgbWVtb3J5LCBzdGFr ZSB0aGUgY2xhaW0sIHN1Y2Nlc3MhICovCisgICAgZC0+dW5jbGFpbWVkX3BhZ2VzID0gY2xhaW07 CisgICAgdG90YWxfdW5jbGFpbWVkX3BhZ2VzICs9IGQtPnVuY2xhaW1lZF9wYWdlczsKKyAgICBy ZXQgPSAwOworCitvdXQ6CisgICAgc3Bpbl91bmxvY2soJmhlYXBfbG9jayk7CisgICAgc3Bpbl91 bmxvY2soJmQtPnBhZ2VfYWxsb2NfbG9jayk7CisgICAgcmV0dXJuIHJldDsKK30KKworbG9uZyBn ZXRfdG90YWxfdW5jbGFpbWVkX3BhZ2VzKHZvaWQpCit7CisgICAgcmV0dXJuIHRvdGFsX3VuY2xh aW1lZF9wYWdlczsKK30KIAogc3RhdGljIHVuc2lnbmVkIGxvbmcgaW5pdF9ub2RlX2hlYXAoaW50 IG5vZGUsIHVuc2lnbmVkIGxvbmcgbWZuLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgdW5zaWduZWQgbG9uZyBuciwgYm9vbF90ICp1c2VfdGFpbCkKQEAgLTM3NCw3ICs0Nzks NyBAQCBzdGF0aWMgdm9pZCBfX2luaXQgc2V0dXBfbG93X21lbV92aXJxKHZvaWQpCiBzdGF0aWMg dm9pZCBjaGVja19sb3dfbWVtX3ZpcnEodm9pZCkKIHsKICAgICB1bnNpZ25lZCBsb25nIGF2YWls X3BhZ2VzID0gdG90YWxfYXZhaWxfcGFnZXMgKwotICAgICAgICAob3B0X3RtZW0gPyB0bWVtX2Zy ZWVhYmxlX3BhZ2VzKCkgOiAwKTsKKyAgICAgICAgKG9wdF90bWVtID8gdG1lbV9mcmVlYWJsZV9w YWdlcygpIDogMCkgLSB0b3RhbF91bmNsYWltZWRfcGFnZXM7CiAKICAgICBpZiAoIHVubGlrZWx5 KGF2YWlsX3BhZ2VzIDw9IGxvd19tZW1fdmlycV90aCkgKQogICAgIHsKQEAgLTQ0Myw2ICs1NDgs MTUgQEAgc3RhdGljIHN0cnVjdCBwYWdlX2luZm8gKmFsbG9jX2hlYXBfcGFnZXMoCiAgICAgc3Bp bl9sb2NrKCZoZWFwX2xvY2spOwogCiAgICAgLyoKKyAgICAgKiBDbGFpbWVkIG1lbW9yeSBpcyBj b25zaWRlcmVkIHVuYXZhaWxhYmxlIHVubGVzcyB0aGUgcmVxdWVzdAorICAgICAqIGlzIG1hZGUg YnkgYSBkb21haW4gd2l0aCBzdWZmaWNpZW50IHVuY2xhaW1lZCBwYWdlcy4KKyAgICAgKi8KKyAg ICBpZiAoICh0b3RhbF91bmNsYWltZWRfcGFnZXMgKyByZXF1ZXN0ID4KKyAgICAgICAgICB0b3Rh bF9hdmFpbF9wYWdlcyArIHRtZW1fZnJlZWFibGVfcGFnZXMoKSkgJiYKKyAgICAgICAgICAoZCA9 PSBOVUxMIHx8IGQtPnVuY2xhaW1lZF9wYWdlcyA8IHJlcXVlc3QpICkKKyAgICAgICAgZ290byBu b3RfZm91bmQ7CisKKyAgICAvKgogICAgICAqIFRNRU06IFdoZW4gYXZhaWxhYmxlIG1lbW9yeSBp cyBzY2FyY2UgZHVlIHRvIHRtZW0gYWJzb3JiaW5nIGl0LCBhbGxvdwogICAgICAqIG9ubHkgbWlk LXNpemUgYWxsb2NhdGlvbnMgdG8gYXZvaWQgd29yc3Qgb2YgZnJhZ21lbnRhdGlvbiBpc3N1ZXMu CiAgICAgICogT3RoZXJzIHRyeSB0bWVtIHBvb2xzIHRoZW4gZmFpbC4gIFRoaXMgaXMgYSB3b3Jr YXJvdW5kIHVudGlsIGFsbApAQCAtMTI5MSw3ICsxNDA1LDcgQEAgaW50IGFzc2lnbl9wYWdlcygK ICAgICAgICAgaWYgKCB1bmxpa2VseShkLT50b3RfcGFnZXMgPT0gMCkgKQogICAgICAgICAgICAg Z2V0X2tub3duYWxpdmVfZG9tYWluKGQpOwogCi0gICAgICAgIGQtPnRvdF9wYWdlcyArPSAxIDw8 IG9yZGVyOworICAgICAgICBkb21haW5faW5jcmVhc2VfdG90X3BhZ2VzKGQsIDEgPDwgb3JkZXIp OwogICAgIH0KIAogICAgIGZvciAoIGkgPSAwOyBpIDwgKDEgPDwgb3JkZXIpOyBpKysgKQpAQCAt MTM3NSw3ICsxNDg5LDcgQEAgdm9pZCBmcmVlX2RvbWhlYXBfcGFnZXMoc3RydWN0IHBhZ2VfaW5m byAqcGcsIHVuc2lnbmVkIGludCBvcmRlcikKICAgICAgICAgICAgIHBhZ2VfbGlzdF9kZWwyKCZw Z1tpXSwgJmQtPnBhZ2VfbGlzdCwgJmQtPmFyY2gucmVsbWVtX2xpc3QpOwogICAgICAgICB9CiAK LSAgICAgICAgZC0+dG90X3BhZ2VzIC09IDEgPDwgb3JkZXI7CisgICAgICAgIGRvbWFpbl9kZWNy ZWFzZV90b3RfcGFnZXMoZCwgMSA8PCBvcmRlcik7CiAgICAgICAgIGRyb3BfZG9tX3JlZiA9IChk LT50b3RfcGFnZXMgPT0gMCk7CiAKICAgICAgICAgc3Bpbl91bmxvY2tfcmVjdXJzaXZlKCZkLT5w YWdlX2FsbG9jX2xvY2spOwpkaWZmIC0tZ2l0IGEveGVuL2luY2x1ZGUvcHVibGljL2RvbWN0bC5o IGIveGVuL2luY2x1ZGUvcHVibGljL2RvbWN0bC5oCmluZGV4IDdjMGYyM2QuLjU3MzVjMjggMTAw NjQ0Ci0tLSBhL3hlbi9pbmNsdWRlL3B1YmxpYy9kb21jdGwuaAorKysgYi94ZW4vaW5jbHVkZS9w dWJsaWMvZG9tY3RsLmgKQEAgLTM2LDcgKzM2LDcgQEAKICNpbmNsdWRlICJncmFudF90YWJsZS5o IgogI2luY2x1ZGUgImh2bS9zYXZlLmgiCiAKLSNkZWZpbmUgWEVOX0RPTUNUTF9JTlRFUkZBQ0Vf VkVSU0lPTiAweDAwMDAwMDA4CisjZGVmaW5lIFhFTl9ET01DVExfSU5URVJGQUNFX1ZFUlNJT04g MHgwMDAwMDAwOQogCiAvKgogICogTkIuIHhlbl9kb21jdGwuZG9tYWluIGlzIGFuIElOL09VVCBw YXJhbWV0ZXIgZm9yIHRoaXMgb3BlcmF0aW9uLgpAQCAtOTUsNiArOTUsNyBAQCBzdHJ1Y3QgeGVu X2RvbWN0bF9nZXRkb21haW5pbmZvIHsKICAgICB1aW50MzJfdCBmbGFnczsgICAgICAgICAgICAg IC8qIFhFTl9ET01JTkZfKiAqLwogICAgIHVpbnQ2NF9hbGlnbmVkX3QgdG90X3BhZ2VzOwogICAg IHVpbnQ2NF9hbGlnbmVkX3QgbWF4X3BhZ2VzOworICAgIHVpbnQ2NF9hbGlnbmVkX3QgdW5jbGFp bWVkX3BhZ2VzOwogICAgIHVpbnQ2NF9hbGlnbmVkX3Qgc2hyX3BhZ2VzOwogICAgIHVpbnQ2NF9h bGlnbmVkX3QgcGFnZWRfcGFnZXM7CiAgICAgdWludDY0X2FsaWduZWRfdCBzaGFyZWRfaW5mb19m cmFtZTsgLyogR01GTiBvZiBzaGFyZWRfaW5mbyBzdHJ1Y3QgKi8KZGlmZiAtLWdpdCBhL3hlbi9p bmNsdWRlL3B1YmxpYy9tZW1vcnkuaCBiL3hlbi9pbmNsdWRlL3B1YmxpYy9tZW1vcnkuaAppbmRl eCBmMWRkYmMwLi4xNWQ2YzcyIDEwMDY0NAotLS0gYS94ZW4vaW5jbHVkZS9wdWJsaWMvbWVtb3J5 LmgKKysrIGIveGVuL2luY2x1ZGUvcHVibGljL21lbW9yeS5oCkBAIC02OCw2ICs2OCw4IEBAIHN0 cnVjdCB4ZW5fbWVtb3J5X3Jlc2VydmF0aW9uIHsKICAgICAgKiAgIElOOiAgR1BGTiBiYXNlcyBv ZiBleHRlbnRzIHRvIHBvcHVsYXRlIHdpdGggbWVtb3J5CiAgICAgICogICBPVVQ6IEdNRk4gYmFz ZXMgb2YgZXh0ZW50cyB0aGF0IHdlcmUgYWxsb2NhdGVkCiAgICAgICogICAoTkIuIFRoaXMgY29t bWFuZCBhbHNvIHVwZGF0ZXMgdGhlIG1hY2hfdG9fcGh5cyB0cmFuc2xhdGlvbiB0YWJsZSkKKyAg ICAgKiBYRU5NRU1fY2xhaW1fcGFnZXM6CisgICAgICogICBJTjogbXVzdCBiZSB6ZXJvCiAgICAg ICovCiAgICAgWEVOX0dVRVNUX0hBTkRMRSh4ZW5fcGZuX3QpIGV4dGVudF9zdGFydDsKIApAQCAt NDIxLDYgKzQyMyw0MyBAQCBzdHJ1Y3QgeGVuX21lbV9zaGFyaW5nX29wIHsKIHR5cGVkZWYgc3Ry dWN0IHhlbl9tZW1fc2hhcmluZ19vcCB4ZW5fbWVtX3NoYXJpbmdfb3BfdDsKIERFRklORV9YRU5f R1VFU1RfSEFORExFKHhlbl9tZW1fc2hhcmluZ19vcF90KTsKIAorLyoKKyAqIEF0dGVtcHQgdG8g c3Rha2UgYSBjbGFpbSBmb3IgYSBkb21haW4gb24gYSBxdWFudGl0eSBvZiBwYWdlcworICogb2Yg c3lzdGVtIFJBTSwgYnV0IF9ub3RfIGFzc2lnbiBzcGVjaWZpYyBwYWdlZnJhbWVzLiAgT25seQor ICogYXJpdGhtZXRpYyBpcyBwZXJmb3JtZWQgc28gdGhlIGh5cGVyY2FsbCBpcyB2ZXJ5IGZhc3Qg YW5kIG5lZWQKKyAqIG5vdCBiZSBwcmVlbXB0aWJsZSwgdGh1cyBzaWRlc3RlcHBpbmcgdGltZS1v Zi1jaGVjay10aW1lLW9mLXVzZQorICogcmFjZXMgZm9yIG1lbW9yeSBhbGxvY2F0aW9uLiAgUmV0 dXJucyAwIGlmIHRoZSBoeXBlcnZpc29yIHBhZ2UKKyAqIGFsbG9jYXRvciBoYXMgYXRvbWljYWxs eSBhbmQgc3VjY2Vzc2Z1bGx5IGNsYWltZWQgdGhlIHJlcXVlc3RlZAorICogbnVtYmVyIG9mIHBh Z2VzLCBlbHNlIG5vbi16ZXJvLgorICoKKyAqIEFueSBkb21haW4gbWF5IGhhdmUgb25seSBvbmUg YWN0aXZlIGNsYWltLiAgV2hlbiBzdWZmaWNpZW50IG1lbW9yeQorICogaGFzIGJlZW4gYWxsb2Nh dGVkIHRvIHJlc29sdmUgdGhlIGNsYWltLCB0aGUgY2xhaW0gc2lsZW50bHkgZXhwaXJlcy4KKyAq IENsYWltaW5nIHplcm8gcGFnZXMgZWZmZWN0aXZlbHkgcmVzZXRzIGFueSBvdXRzdGFuZGluZyBj bGFpbSBhbmQKKyAqIGlzIGFsd2F5cyBzdWNjZXNzZnVsLgorICoKKyAqIE5vdGUgdGhhdCBhIHZh bGlkIGNsYWltIG1heSBiZSBzdGFrZWQgZXZlbiBhZnRlciBtZW1vcnkgaGFzIGJlZW4KKyAqIGFs bG9jYXRlZCBmb3IgYSBkb21haW4uICBJbiB0aGlzIGNhc2UsIHRoZSBjbGFpbSBpcyBub3QgaW5j cmVtZW50YWwsCisgKiBpLmUuIGlmIHRoZSBkb21haW4ncyB0b3RfcGFnZXMgaXMgMywgYW5kIGEg Y2xhaW0gaXMgc3Rha2VkIGZvciAxMCwKKyAqIG9ubHkgNyBhZGRpdGlvbmFsIHBhZ2VzIGFyZSBj bGFpbWVkLgorICoKKyAqIENhbGxlciBtdXN0IGJlIHByaXZpbGVnZWQgb3IgdGhlIGh5cGVyY2Fs bCBmYWlscy4KKyAqLworI2RlZmluZSBYRU5NRU1fY2xhaW1fcGFnZXMgICAgICAgICAgICAgICAg ICAyNAorLyoKKyAqIFhFTk1FTV9jbGFpbV9wYWdlcyBmbGFnczoKKyAqICBmcmVlX29ubHk6IGNs YWltIGlzIHN1Y2Nlc3NmdWwgb25seSBpZiBzdWZmaWNpZW50IGZyZWUgcGFnZXMKKyAqICAgIGFy ZSBhdmFpbGFibGUuICBJZiBub3Qgc2V0IGFuZCB0bWVtIGlzIGVuYWJsZWQsIGh5cGVydmlzb3IK KyAqICAgIG1heSBhbHNvIGNvbnNpZGVyIHRtZW0gImZyZWVhYmxlIiBwYWdlcyB0byBzYXRpc2Z5 IHRoZSBjbGFpbS4KKyAqLworI2RlZmluZSBfWEVOTUVNX0NMQUlNRl9mcmVlX29ubHkgICAgICAg ICAgICAwCisjZGVmaW5lIFhFTk1FTV9DTEFJTUZfZnJlZV9vbmx5ICAgICAgICAgICAgICgxVTw8 X1hFTk1FTV9DTEFJTUZfZnJlZV9vbmx5KQorLyoKKyAqIEdldCB0aGUgbnVtYmVyIG9mIHBhZ2Vz IGN1cnJlbnRseSBjbGFpbWVkIChidXQgbm90IHlldCAicG9zc2Vzc2VkIikKKyAqIGFjcm9zcyBh bGwgZG9tYWlucy4gIFRoZSBjYWxsZXIgbXVzdCBiZSBwcml2aWxlZ2VkIGJ1dCBvdGhlcndpc2UK KyAqIHRoZSBjYWxsIG5ldmVyIGZhaWxzLiAKKyAqLworI2RlZmluZSBYRU5NRU1fZ2V0X3VuY2xh aW1lZF9wYWdlcyAgICAgICAgICAgIDI1CisKICNlbmRpZiAvKiBkZWZpbmVkKF9fWEVOX18pIHx8 IGRlZmluZWQoX19YRU5fVE9PTFNfXykgKi8KIAogI2VuZGlmIC8qIF9fWEVOX1BVQkxJQ19NRU1P UllfSF9fICovCmRpZmYgLS1naXQgYS94ZW4vaW5jbHVkZS94ZW4vbW0uaCBiL3hlbi9pbmNsdWRl L3hlbi9tbS5oCmluZGV4IDY0YTBjYzEuLmI0ZGVlOTIgMTAwNjQ0Ci0tLSBhL3hlbi9pbmNsdWRl L3hlbi9tbS5oCisrKyBiL3hlbi9pbmNsdWRlL3hlbi9tbS5oCkBAIC00OCw2ICs0OCwxMyBAQCB2 b2lkIGZyZWVfeGVuaGVhcF9wYWdlcyh2b2lkICp2LCB1bnNpZ25lZCBpbnQgb3JkZXIpOwogI2Rl ZmluZSBhbGxvY194ZW5oZWFwX3BhZ2UoKSAoYWxsb2NfeGVuaGVhcF9wYWdlcygwLDApKQogI2Rl ZmluZSBmcmVlX3hlbmhlYXBfcGFnZSh2KSAoZnJlZV94ZW5oZWFwX3BhZ2VzKHYsMCkpCiAKKy8q IENsYWltIGhhbmRsaW5nICovCit1bnNpZ25lZCBsb25nIGRvbWFpbl9pbmNyZWFzZV90b3RfcGFn ZXMoc3RydWN0IGRvbWFpbiAqZCwgdW5zaWduZWQgbG9uZyBwYWdlcyk7Cit1bnNpZ25lZCBsb25n IGRvbWFpbl9kZWNyZWFzZV90b3RfcGFnZXMoc3RydWN0IGRvbWFpbiAqZCwgdW5zaWduZWQgbG9u ZyBwYWdlcyk7CitpbnQgZG9tYWluX3NldF91bmNsYWltZWRfcGFnZXMoCisgICAgc3RydWN0IGRv bWFpbiAqZCwgdW5zaWduZWQgbG9uZyBwYWdlcywgdW5zaWduZWQgbG9uZyBmbGFncyk7Citsb25n IGdldF90b3RhbF91bmNsYWltZWRfcGFnZXModm9pZCk7CisKIC8qIERvbWFpbiBzdWJhbGxvY2F0 b3IuIFRoZXNlIGZ1bmN0aW9ucyBhcmUgKm5vdCogaW50ZXJydXB0LXNhZmUuKi8KIHZvaWQgaW5p dF9kb21oZWFwX3BhZ2VzKHBhZGRyX3QgcHMsIHBhZGRyX3QgcGUpOwogc3RydWN0IHBhZ2VfaW5m byAqYWxsb2NfZG9taGVhcF9wYWdlcygKZGlmZiAtLWdpdCBhL3hlbi9pbmNsdWRlL3hlbi9zY2hl ZC5oIGIveGVuL2luY2x1ZGUveGVuL3NjaGVkLmgKaW5kZXggNmM1NTAzOS4uNDgwZWYzOSAxMDA2 NDQKLS0tIGEveGVuL2luY2x1ZGUveGVuL3NjaGVkLmgKKysrIGIveGVuL2luY2x1ZGUveGVuL3Nj aGVkLmgKQEAgLTI0Miw2ICsyNDIsNyBAQCBzdHJ1Y3QgZG9tYWluCiAgICAgc3RydWN0IHBhZ2Vf bGlzdF9oZWFkIHBhZ2VfbGlzdDsgIC8qIGxpbmtlZCBsaXN0ICovCiAgICAgc3RydWN0IHBhZ2Vf bGlzdF9oZWFkIHhlbnBhZ2VfbGlzdDsgLyogbGlua2VkIGxpc3QgKHNpemUgeGVuaGVhcF9wYWdl cykgKi8KICAgICB1bnNpZ25lZCBpbnQgICAgIHRvdF9wYWdlczsgICAgICAgLyogbnVtYmVyIG9m IHBhZ2VzIGN1cnJlbnRseSBwb3NzZXNlZCAqLworICAgIHVuc2lnbmVkIGludCAgICAgdW5jbGFp bWVkX3BhZ2VzOyAvKiBwYWdlcyBjbGFpbWVkIGJ1dCBub3QgcG9zc2Vzc2VkICAgICovCiAgICAg dW5zaWduZWQgaW50ICAgICBtYXhfcGFnZXM7ICAgICAgIC8qIG1heGltdW0gdmFsdWUgZm9yIHRv dF9wYWdlcyAgICAgICAgKi8KICAgICBhdG9taWNfdCAgICAgICAgIHNocl9wYWdlczsgICAgICAg LyogbnVtYmVyIG9mIHNoYXJlZCBwYWdlcyAgICAgICAgICAgICAqLwogICAgIGF0b21pY190ICAg ICAgICAgcGFnZWRfcGFnZXM7ICAgICAvKiBudW1iZXIgb2YgcGFnZWQtb3V0IHBhZ2VzICAgICAg ICAgICovCg== --__135395347276233805abhmt116.oracle.com Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel --__135395347276233805abhmt116.oracle.com--