From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dan Magenheimer Subject: [RFC/PATCH v2] XENMEM_claim_pages (subop of existing) hypercall Date: Wed, 14 Nov 2012 15:55:45 -0800 (PST) Message-ID: <6f7c28bb-ffa9-4b39-929b-2a05d99a77e7@default> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="__1352937350095136424abhmt108.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 Cc: Zhigang Wang , Konrad Wilk , xen-devel@lists.xen.org List-Id: xen-devel@lists.xenproject.org --__1352937350095136424abhmt108.oracle.com Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: quoted-printable This is a second cut of the hypervisor patch of the proposed XENMEM_claim_pages hypercall/subop, taking into account feedback from Jan and Keir, plus some fixes found via runtime debugging (using privcmd only) and some comments/cleanup. 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. I don't have a patch for the toolstack side, but I envision a "xl create --claim" option to maximize backwards compatibility while minimizing impact on existing toolstacks. As a result, testing has (so far) only been done via privcmd. 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 (d->tot_pages may normally be zero but see Note 1). 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. See Note 2. 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). Note 1: Tim: I'm thinking this may resolve your concern that the claim mechanism must be more complicated to handle restricted memory allocations and order>0 allocations. The proposed claim mechanism only guarantees a quantity of order=3D=3D0 pages; if restricted allocations are required, these are done first by the toolstack, and followed by the claim. Order>0 allocations still work if memory is not fragmented, but the claim mechanism doesn't guarantee anything but a quantity of order=3D=3D0 pages. Note 2: Tim: This arithmetic also indirectly implements the "claim auto-expire" discussed earlier. We certainly don't want a negative claim. It's possible that the toolstack need never call "unclaim" (and so such a hypercall/subop need not even exist) as long as domain_reset_unclaimed_pages() is called when a domain dies. This draft doesn't even provide unclaim... though if a reason for its existence is determined, it should be easy to add. Note 3: There is currently no way to observe a staked claim, so a staked claim will not survive a save/restore/migrate. Not clear yet if this is needed but could be added. Thanks for any feedback! Signed-off-by: Dan Magenheimer 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..943a3b5 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 0 ) 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 0e3e36a..95509e2 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/grant_table.c b/xen/common/grant_table.c index 7912769..10ce78f 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 0) ) 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..38f2cb9 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,35 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_= PARAM(void) arg) break; } =20 + case XENMEM_claim_pages: + { + unsigned long request; + + start_extent =3D cmd >> MEMOP_EXTENT_SHIFT; + + if ( copy_from_guest(&reservation, arg, 1) ) + return start_extent; + + if ( !(guest_handle_is_null(reservation.extent_start)) ) + return start_extent; + + rc =3D rcu_lock_target_domain_by_id(reservation.domid, &d); + if ( rc ) + return rc; + + /* + * extent_order may be non-zero, but is only a multiplier and + * does not currently claim any order>0 slabs, though this is + * a possible future feature + */ + request =3D reservation.nr_extents << reservation.extent_order; + rc =3D domain_set_unclaimed_pages(d, request, reservation.mem_flag= s); + + rcu_unlock_domain(d); + + 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..178d816 100644 --- a/xen/common/page_alloc.c +++ b/xen/common/page_alloc.c @@ -238,6 +238,100 @@ 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)); + ASSERT(!spin_is_locked(&heap_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)); + ASSERT(!spin_is_locked(&heap_lock)); + spin_lock(&heap_lock); + d->tot_pages -=3D pages; + if ( d->unclaimed_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 =3D 0, avail_pages =3D 0; + + /* + * 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 + */ + ASSERT(!spin_is_locked(&d->page_alloc_lock)); + spin_lock(&d->page_alloc_lock); + ASSERT(!spin_is_locked(&heap_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) + 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; +} =20 static unsigned long init_node_heap(int node, unsigned long mfn, unsigned long nr, bool_t *use_tail) @@ -443,6 +537,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 +1394,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 +1478,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/memory.h b/xen/include/public/memory.h index f1ddbc0..c4de5c1 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,35 @@ 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. + */ +#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) + #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..5c63581 100644 --- a/xen/include/xen/mm.h +++ b/xen/include/xen/mm.h @@ -48,6 +48,12 @@ 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); + /* 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 = */ --__1352937350095136424abhmt108.oracle.com Content-Type: application/octet-stream; name="claim-121114.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="claim-121114.patch" ZGlmZiAtLWdpdCBhL3hlbi9hcmNoL3g4Ni9tbS5jIGIveGVuL2FyY2gveDg2L21tLmMKaW5kZXgg ZmFkM2QzMy4uN2U1NTkwOCAxMDA2NDQKLS0tIGEveGVuL2FyY2gveDg2L21tLmMKKysrIGIveGVu L2FyY2gveDg2L21tLmMKQEAgLTM4NDEsNyArMzg0MSw3IEBAIGludCBkb25hdGVfcGFnZSgKICAg ICB7CiAgICAgICAgIGlmICggZC0+dG90X3BhZ2VzID49IGQtPm1heF9wYWdlcyApCiAgICAgICAg ICAgICBnb3RvIGZhaWw7Ci0gICAgICAgIGQtPnRvdF9wYWdlcysrOworICAgICAgICBkb21haW5f aW5jcmVhc2VfdG90X3BhZ2VzKGQsIDEpOwogICAgIH0KIAogICAgIHBhZ2UtPmNvdW50X2luZm8g PSBQR0NfYWxsb2NhdGVkIHwgMTsKZGlmZiAtLWdpdCBhL3hlbi9hcmNoL3g4Ni9tbS9tZW1fc2hh cmluZy5jIGIveGVuL2FyY2gveDg2L21tL21lbV9zaGFyaW5nLmMKaW5kZXggNTEwMzI4NS4uOTQz YTNiNSAxMDA2NDQKLS0tIGEveGVuL2FyY2gveDg2L21tL21lbV9zaGFyaW5nLmMKKysrIGIveGVu L2FyY2gveDg2L21tL21lbV9zaGFyaW5nLmMKQEAgLTYzOSw3ICs2MzksNyBAQCBzdGF0aWMgaW50 IHBhZ2VfbWFrZV9zaGFyYWJsZShzdHJ1Y3QgZG9tYWluICpkLAogICAgIH0KIAogICAgIHBhZ2Vf c2V0X293bmVyKHBhZ2UsIGRvbV9jb3cpOwotICAgIGQtPnRvdF9wYWdlcy0tOworICAgIGRvbWFp bl9kZWNyZWFzZV90b3RfcGFnZXMoZCwgMSk7CiAgICAgZHJvcF9kb21fcmVmID0gKGQtPnRvdF9w YWdlcyA9PSAwKTsKICAgICBwYWdlX2xpc3RfZGVsKHBhZ2UsICZkLT5wYWdlX2xpc3QpOwogICAg IHNwaW5fdW5sb2NrKCZkLT5wYWdlX2FsbG9jX2xvY2spOwpAQCAtNjgwLDcgKzY4MCw3IEBAIHN0 YXRpYyBpbnQgcGFnZV9tYWtlX3ByaXZhdGUoc3RydWN0IGRvbWFpbiAqZCwgc3RydWN0IHBhZ2Vf aW5mbyAqcGFnZSkKICAgICBBU1NFUlQocGFnZV9nZXRfb3duZXIocGFnZSkgPT0gZG9tX2Nvdyk7 CiAgICAgcGFnZV9zZXRfb3duZXIocGFnZSwgZCk7CiAKLSAgICBpZiAoIGQtPnRvdF9wYWdlcysr ID09IDAgKQorICAgIGlmICggZG9tYWluX2luY3JlYXNlX3RvdF9wYWdlcyhkLCAxKSA9PSAwICkK ICAgICAgICAgZ2V0X2RvbWFpbihkKTsKICAgICBwYWdlX2xpc3RfYWRkX3RhaWwocGFnZSwgJmQt PnBhZ2VfbGlzdCk7CiAgICAgc3Bpbl91bmxvY2soJmQtPnBhZ2VfYWxsb2NfbG9jayk7CmRpZmYg LS1naXQgYS94ZW4vY29tbW9uL2RvbWFpbi5jIGIveGVuL2NvbW1vbi9kb21haW4uYwppbmRleCAw ZTNlMzZhLi45NTUwOWUyIDEwMDY0NAotLS0gYS94ZW4vY29tbW9uL2RvbWFpbi5jCisrKyBiL3hl bi9jb21tb24vZG9tYWluLmMKQEAgLTQ5Miw2ICs0OTIsNyBAQCBpbnQgZG9tYWluX2tpbGwoc3Ry dWN0IGRvbWFpbiAqZCkKICAgICAgICAgZXZ0Y2huX2Rlc3Ryb3koZCk7CiAgICAgICAgIGdudHRh Yl9yZWxlYXNlX21hcHBpbmdzKGQpOwogICAgICAgICB0bWVtX2Rlc3Ryb3koZC0+dG1lbSk7Cisg ICAgICAgIGRvbWFpbl9zZXRfdW5jbGFpbWVkX3BhZ2VzKGQsIDAsIDApOwogICAgICAgICBkLT50 bWVtID0gTlVMTDsKICAgICAgICAgLyogZmFsbHRocm91Z2ggKi8KICAgICBjYXNlIERPTURZSU5H X2R5aW5nOgpkaWZmIC0tZ2l0IGEveGVuL2NvbW1vbi9ncmFudF90YWJsZS5jIGIveGVuL2NvbW1v bi9ncmFudF90YWJsZS5jCmluZGV4IDc5MTI3NjkuLjEwY2U3OGYgMTAwNjQ0Ci0tLSBhL3hlbi9j b21tb24vZ3JhbnRfdGFibGUuYworKysgYi94ZW4vY29tbW9uL2dyYW50X3RhYmxlLmMKQEAgLTE2 NTYsNyArMTY1Niw3IEBAIGdudHRhYl90cmFuc2ZlcigKICAgICAgICAgfQogCiAgICAgICAgIC8q IE9rYXksIGFkZCB0aGUgcGFnZSB0byAnZScuICovCi0gICAgICAgIGlmICggdW5saWtlbHkoZS0+ dG90X3BhZ2VzKysgPT0gMCkgKQorICAgICAgICBpZiAoIHVubGlrZWx5KGRvbWFpbl9pbmNyZWFz ZV90b3RfcGFnZXMoZSwgMSkgPT0gMCkgKQogICAgICAgICAgICAgZ2V0X2tub3duYWxpdmVfZG9t YWluKGUpOwogICAgICAgICBwYWdlX2xpc3RfYWRkX3RhaWwocGFnZSwgJmUtPnBhZ2VfbGlzdCk7 CiAgICAgICAgIHBhZ2Vfc2V0X293bmVyKHBhZ2UsIGUpOwpkaWZmIC0tZ2l0IGEveGVuL2NvbW1v bi9tZW1vcnkuYyBiL3hlbi9jb21tb24vbWVtb3J5LmMKaW5kZXggODNlMjY2Ni4uMzhmMmNiOSAx MDA2NDQKLS0tIGEveGVuL2NvbW1vbi9tZW1vcnkuYworKysgYi94ZW4vY29tbW9uL21lbW9yeS5j CkBAIC00NTQsNyArNDU0LDcgQEAgc3RhdGljIGxvbmcgbWVtb3J5X2V4Y2hhbmdlKFhFTl9HVUVT VF9IQU5ETEVfUEFSQU0oeGVuX21lbW9yeV9leGNoYW5nZV90KSBhcmcpCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIChqICogKDFVTCA8PCBleGNoLm91dC5leHRlbnRfb3JkZXIpKSk7CiAK ICAgICAgICAgICAgICAgICBzcGluX2xvY2soJmQtPnBhZ2VfYWxsb2NfbG9jayk7Ci0gICAgICAg ICAgICAgICAgZC0+dG90X3BhZ2VzIC09IGRlY19jb3VudDsKKyAgICAgICAgICAgICAgICBkb21h aW5fZGVjcmVhc2VfdG90X3BhZ2VzKGQsIGRlY19jb3VudCk7CiAgICAgICAgICAgICAgICAgZHJv cF9kb21fcmVmID0gKGRlY19jb3VudCAmJiAhZC0+dG90X3BhZ2VzKTsKICAgICAgICAgICAgICAg ICBzcGluX3VubG9jaygmZC0+cGFnZV9hbGxvY19sb2NrKTsKIApAQCAtNjg1LDYgKzY4NSwzNSBA QCBsb25nIGRvX21lbW9yeV9vcCh1bnNpZ25lZCBsb25nIGNtZCwgWEVOX0dVRVNUX0hBTkRMRV9Q QVJBTSh2b2lkKSBhcmcpCiAgICAgICAgIGJyZWFrOwogICAgIH0KIAorICAgIGNhc2UgWEVOTUVN X2NsYWltX3BhZ2VzOgorICAgIHsKKyAgICAgICAgdW5zaWduZWQgbG9uZyByZXF1ZXN0OworCisg ICAgICAgIHN0YXJ0X2V4dGVudCA9IGNtZCA+PiBNRU1PUF9FWFRFTlRfU0hJRlQ7CisKKyAgICAg ICAgaWYgKCBjb3B5X2Zyb21fZ3Vlc3QoJnJlc2VydmF0aW9uLCBhcmcsIDEpICkKKyAgICAgICAg ICAgIHJldHVybiBzdGFydF9leHRlbnQ7CisKKyAgICAgICAgaWYgKCAhKGd1ZXN0X2hhbmRsZV9p c19udWxsKHJlc2VydmF0aW9uLmV4dGVudF9zdGFydCkpICkKKyAgICAgICAgICAgIHJldHVybiBz dGFydF9leHRlbnQ7CisKKyAgICAgICAgcmMgPSByY3VfbG9ja190YXJnZXRfZG9tYWluX2J5X2lk KHJlc2VydmF0aW9uLmRvbWlkLCAmZCk7CisgICAgICAgIGlmICggcmMgKQorICAgICAgICAgICAg cmV0dXJuIHJjOworCisgICAgICAgIC8qCisgICAgICAgICAqIGV4dGVudF9vcmRlciBtYXkgYmUg bm9uLXplcm8sIGJ1dCBpcyBvbmx5IGEgbXVsdGlwbGllciBhbmQKKyAgICAgICAgICogZG9lcyBu b3QgY3VycmVudGx5IGNsYWltIGFueSBvcmRlcj4wIHNsYWJzLCB0aG91Z2ggdGhpcyBpcworICAg ICAgICAgKiBhIHBvc3NpYmxlIGZ1dHVyZSBmZWF0dXJlCisgICAgICAgICAqLworICAgICAgICBy ZXF1ZXN0ID0gcmVzZXJ2YXRpb24ubnJfZXh0ZW50cyA8PCByZXNlcnZhdGlvbi5leHRlbnRfb3Jk ZXI7CisgICAgICAgIHJjID0gZG9tYWluX3NldF91bmNsYWltZWRfcGFnZXMoZCwgcmVxdWVzdCwg cmVzZXJ2YXRpb24ubWVtX2ZsYWdzKTsKKworICAgICAgICByY3VfdW5sb2NrX2RvbWFpbihkKTsK KworICAgICAgICBicmVhazsKKyAgICB9CisKICAgICBkZWZhdWx0OgogICAgICAgICByYyA9IGFy Y2hfbWVtb3J5X29wKG9wLCBhcmcpOwogICAgICAgICBicmVhazsKZGlmZiAtLWdpdCBhL3hlbi9j b21tb24vcGFnZV9hbGxvYy5jIGIveGVuL2NvbW1vbi9wYWdlX2FsbG9jLmMKaW5kZXggMTVlYmM2 Ni4uMTc4ZDgxNiAxMDA2NDQKLS0tIGEveGVuL2NvbW1vbi9wYWdlX2FsbG9jLmMKKysrIGIveGVu L2NvbW1vbi9wYWdlX2FsbG9jLmMKQEAgLTIzOCw2ICsyMzgsMTAwIEBAIHN0YXRpYyBsb25nIG1p ZHNpemVfYWxsb2Nfem9uZV9wYWdlczsKICNkZWZpbmUgTUlEU0laRV9BTExPQ19GUkFDIDEyOAog CiBzdGF0aWMgREVGSU5FX1NQSU5MT0NLKGhlYXBfbG9jayk7CitzdGF0aWMgbG9uZyB0b3RhbF91 bmNsYWltZWRfcGFnZXM7IC8qIHRvdGFsIG91dHN0YW5kaW5nIGNsYWltcyBieSBhbGwgZG9tYWlu cyAqLworCit1bnNpZ25lZCBsb25nIGRvbWFpbl9pbmNyZWFzZV90b3RfcGFnZXMoc3RydWN0IGRv bWFpbiAqZCwgdW5zaWduZWQgbG9uZyBwYWdlcykKK3sKKyAgICBsb25nIGRvbV9iZWZvcmUsIGRv bV9hZnRlciwgZG9tX2NsYWltZWQsIHN5c19iZWZvcmUsIHN5c19hZnRlcjsKKworICAgIEFTU0VS VChzcGluX2lzX2xvY2tlZCgmZC0+cGFnZV9hbGxvY19sb2NrKSk7CisgICAgQVNTRVJUKCFzcGlu X2lzX2xvY2tlZCgmaGVhcF9sb2NrKSk7CisgICAgaWYgKCAhZC0+dW5jbGFpbWVkX3BhZ2VzICkK KyAgICAgICAgcmV0dXJuIGQtPnRvdF9wYWdlcyArPSBwYWdlczsKKyAgICBzcGluX2xvY2soJmhl YXBfbG9jayk7CisgICAgZG9tX2JlZm9yZSA9IGQtPnVuY2xhaW1lZF9wYWdlczsKKyAgICBkb21f YWZ0ZXIgPSBkb21fYmVmb3JlIC0gcGFnZXM7CisgICAgaWYgKCAoZG9tX2JlZm9yZSA+IDApICYm IChkb21fYWZ0ZXIgPCAwKSApCisgICAgICAgIGRvbV9jbGFpbWVkID0gMDsKKyAgICBlbHNlCisg ICAgICAgIGRvbV9jbGFpbWVkID0gZG9tX2FmdGVyOworICAgIHN5c19iZWZvcmUgPSB0b3RhbF91 bmNsYWltZWRfcGFnZXM7CisgICAgc3lzX2FmdGVyID0gc3lzX2JlZm9yZSAtIChkb21fYmVmb3Jl IC0gZG9tX2NsYWltZWQpOworICAgIEJVR19PTiggKHN5c19iZWZvcmUgPiAwKSAmJiAoc3lzX2Fm dGVyIDwgMCkgKTsKKyAgICB0b3RhbF91bmNsYWltZWRfcGFnZXMgPSBzeXNfYWZ0ZXI7CisgICAg ZC0+dW5jbGFpbWVkX3BhZ2VzID0gZG9tX2NsYWltZWQ7CisgICAgc3Bpbl91bmxvY2soJmhlYXBf bG9jayk7CisgICAgcmV0dXJuIGQtPnRvdF9wYWdlczsKK30KKwordW5zaWduZWQgbG9uZyBkb21h aW5fZGVjcmVhc2VfdG90X3BhZ2VzKHN0cnVjdCBkb21haW4gKmQsIHVuc2lnbmVkIGxvbmcgcGFn ZXMpCit7CisgICAgQVNTRVJUKHNwaW5faXNfbG9ja2VkKCZkLT5wYWdlX2FsbG9jX2xvY2spKTsK KyAgICBBU1NFUlQoIXNwaW5faXNfbG9ja2VkKCZoZWFwX2xvY2spKTsKKyAgICBzcGluX2xvY2so JmhlYXBfbG9jayk7CisgICAgZC0+dG90X3BhZ2VzIC09IHBhZ2VzOworICAgIGlmICggZC0+dW5j bGFpbWVkX3BhZ2VzICkKKyAgICB7CisgICAgICAgIGQtPnVuY2xhaW1lZF9wYWdlcyArPSBwYWdl czsKKyAgICAgICAgdG90YWxfdW5jbGFpbWVkX3BhZ2VzICs9IHBhZ2VzOworICAgIH0KKyAgICBz cGluX3VubG9jaygmaGVhcF9sb2NrKTsKKyAgICByZXR1cm4gZC0+dG90X3BhZ2VzOworfQorCitp bnQgZG9tYWluX3NldF91bmNsYWltZWRfcGFnZXMoc3RydWN0IGRvbWFpbiAqZCwgdW5zaWduZWQg bG9uZyBwYWdlcywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgbG9u ZyBmbGFncykKK3sKKyAgICBpbnQgcmV0ID0gLUVOT01FTTsKKyAgICB1bnNpZ25lZCBsb25nIGNs YWltID0gMCwgYXZhaWxfcGFnZXMgPSAwOworCisgICAgLyoKKyAgICAgKiB0YWtlIHRoZSBkb21h aW4ncyBwYWdlX2FsbG9jX2xvY2ssIGVsc2UgYWxsIGluY3JlYXNlcy9kZWNyZWFzZXMKKyAgICAg KiBtdXN0IGFsd2F5cyB0YWtlIHRoZSBnbG9iYWwgaGVhcF9sb2NrIHJhdGhlciB0aGFuIG9ubHkg aW4gdGhlIG11Y2gKKyAgICAgKiByYXJlciBjYXNlIHRoYXQgZC0+dW5jbGFpbWVkX3BhZ2VzIGlz IG5vbi16ZXJvCisgICAgICovCisgICAgQVNTRVJUKCFzcGluX2lzX2xvY2tlZCgmZC0+cGFnZV9h bGxvY19sb2NrKSk7CisgICAgc3Bpbl9sb2NrKCZkLT5wYWdlX2FsbG9jX2xvY2spOworICAgIEFT U0VSVCghc3Bpbl9pc19sb2NrZWQoJmhlYXBfbG9jaykpOworICAgIHNwaW5fbG9jaygmaGVhcF9s b2NrKTsKKworICAgIC8qIHBhZ2VzPT0wIG1lYW5zICJ1bnNldCIgdGhlIGNsYWltIChhbmQgZmxh Z3MgaXMgaWdub3JlZCkgKi8KKyAgICBpZiAocGFnZXMgPT0gMCkKKyAgICB7CisgICAgICAgIHRv dGFsX3VuY2xhaW1lZF9wYWdlcyAtPSBkLT51bmNsYWltZWRfcGFnZXM7CisgICAgICAgIGQtPnVu Y2xhaW1lZF9wYWdlcyA9IDA7CisgICAgICAgIHJldCA9IDA7CisgICAgICAgIGdvdG8gb3V0Owor ICAgIH0KKworICAgIC8qIG9ubHkgb25lIGFjdGl2ZSBjbGFpbSBwZXIgZG9tYWluIHBsZWFzZSAq LworICAgIGlmICggZC0+dW5jbGFpbWVkX3BhZ2VzKQorICAgICAgICBnb3RvIG91dDsKKworICAg IC8qIGhvdyBtdWNoIG1lbW9yeSBpcyBhdmFpbGFibGU/ICovCisgICAgYXZhaWxfcGFnZXMgPSB0 b3RhbF9hdmFpbF9wYWdlczsKKyAgICBpZiAoICEoZmxhZ3MgJiBYRU5NRU1fQ0xBSU1GX2ZyZWVf b25seSkgKQorICAgICAgICBhdmFpbF9wYWdlcyArPSB0bWVtX2ZyZWVhYmxlX3BhZ2VzKCk7Cisg ICAgYXZhaWxfcGFnZXMgLT0gdG90YWxfdW5jbGFpbWVkX3BhZ2VzOworCisgICAgLyoKKyAgICAg KiBub3RlLCBpZiBkb21haW4gaGFzIGFscmVhZHkgYWxsb2NhdGVkIG1lbW9yeSBiZWZvcmUgbWFr aW5nIGEgY2xhaW0gCisgICAgICogdGhlbiB0aGUgY2xhaW0gbXVzdCB0YWtlIHRvdF9wYWdlcyBp bnRvIGFjY291bnQKKyAgICAgKi8KKyAgICBjbGFpbSA9IHBhZ2VzIC0gZC0+dG90X3BhZ2VzOwor ICAgIGlmICggY2xhaW0gPiBhdmFpbF9wYWdlcyApCisgICAgICAgIGdvdG8gb3V0OworCisgICAg LyogeWF5LCBjbGFpbSBmaXRzIGluIGF2YWlsYWJsZSBtZW1vcnksIHN0YWtlIHRoZSBjbGFpbSwg c3VjY2VzcyEgKi8KKyAgICBkLT51bmNsYWltZWRfcGFnZXMgPSBjbGFpbTsKKyAgICB0b3RhbF91 bmNsYWltZWRfcGFnZXMgKz0gZC0+dW5jbGFpbWVkX3BhZ2VzOworICAgIHJldCA9IDA7CisKK291 dDoKKyAgICBzcGluX3VubG9jaygmaGVhcF9sb2NrKTsKKyAgICBzcGluX3VubG9jaygmZC0+cGFn ZV9hbGxvY19sb2NrKTsKKyAgICByZXR1cm4gcmV0OworfQogCiBzdGF0aWMgdW5zaWduZWQgbG9u ZyBpbml0X25vZGVfaGVhcChpbnQgbm9kZSwgdW5zaWduZWQgbG9uZyBtZm4sCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBsb25nIG5yLCBib29sX3QgKnVzZV90 YWlsKQpAQCAtNDQzLDYgKzUzNywxNSBAQCBzdGF0aWMgc3RydWN0IHBhZ2VfaW5mbyAqYWxsb2Nf aGVhcF9wYWdlcygKICAgICBzcGluX2xvY2soJmhlYXBfbG9jayk7CiAKICAgICAvKgorICAgICAq IENsYWltZWQgbWVtb3J5IGlzIGNvbnNpZGVyZWQgdW5hdmFpbGFibGUgdW5sZXNzIHRoZSByZXF1 ZXN0CisgICAgICogaXMgbWFkZSBieSBhIGRvbWFpbiB3aXRoIHN1ZmZpY2llbnQgdW5jbGFpbWVk IHBhZ2VzLgorICAgICAqLworICAgIGlmICggKHRvdGFsX3VuY2xhaW1lZF9wYWdlcyArIHJlcXVl c3QgPgorICAgICAgICAgICB0b3RhbF9hdmFpbF9wYWdlcyArIHRtZW1fZnJlZWFibGVfcGFnZXMo KSkgJiYKKyAgICAgICAgICAoZCA9PSBOVUxMIHx8IGQtPnVuY2xhaW1lZF9wYWdlcyA8IHJlcXVl c3QpICkKKyAgICAgICAgZ290byBub3RfZm91bmQ7CisKKyAgICAvKgogICAgICAqIFRNRU06IFdo ZW4gYXZhaWxhYmxlIG1lbW9yeSBpcyBzY2FyY2UgZHVlIHRvIHRtZW0gYWJzb3JiaW5nIGl0LCBh bGxvdwogICAgICAqIG9ubHkgbWlkLXNpemUgYWxsb2NhdGlvbnMgdG8gYXZvaWQgd29yc3Qgb2Yg ZnJhZ21lbnRhdGlvbiBpc3N1ZXMuCiAgICAgICogT3RoZXJzIHRyeSB0bWVtIHBvb2xzIHRoZW4g ZmFpbC4gIFRoaXMgaXMgYSB3b3JrYXJvdW5kIHVudGlsIGFsbApAQCAtMTI5MSw3ICsxMzk0LDcg QEAgaW50IGFzc2lnbl9wYWdlcygKICAgICAgICAgaWYgKCB1bmxpa2VseShkLT50b3RfcGFnZXMg PT0gMCkgKQogICAgICAgICAgICAgZ2V0X2tub3duYWxpdmVfZG9tYWluKGQpOwogCi0gICAgICAg IGQtPnRvdF9wYWdlcyArPSAxIDw8IG9yZGVyOworICAgICAgICBkb21haW5faW5jcmVhc2VfdG90 X3BhZ2VzKGQsIDEgPDwgb3JkZXIpOwogICAgIH0KIAogICAgIGZvciAoIGkgPSAwOyBpIDwgKDEg PDwgb3JkZXIpOyBpKysgKQpAQCAtMTM3NSw3ICsxNDc4LDcgQEAgdm9pZCBmcmVlX2RvbWhlYXBf cGFnZXMoc3RydWN0IHBhZ2VfaW5mbyAqcGcsIHVuc2lnbmVkIGludCBvcmRlcikKICAgICAgICAg ICAgIHBhZ2VfbGlzdF9kZWwyKCZwZ1tpXSwgJmQtPnBhZ2VfbGlzdCwgJmQtPmFyY2gucmVsbWVt X2xpc3QpOwogICAgICAgICB9CiAKLSAgICAgICAgZC0+dG90X3BhZ2VzIC09IDEgPDwgb3JkZXI7 CisgICAgICAgIGRvbWFpbl9kZWNyZWFzZV90b3RfcGFnZXMoZCwgMSA8PCBvcmRlcik7CiAgICAg ICAgIGRyb3BfZG9tX3JlZiA9IChkLT50b3RfcGFnZXMgPT0gMCk7CiAKICAgICAgICAgc3Bpbl91 bmxvY2tfcmVjdXJzaXZlKCZkLT5wYWdlX2FsbG9jX2xvY2spOwpkaWZmIC0tZ2l0IGEveGVuL2lu Y2x1ZGUvcHVibGljL21lbW9yeS5oIGIveGVuL2luY2x1ZGUvcHVibGljL21lbW9yeS5oCmluZGV4 IGYxZGRiYzAuLmM0ZGU1YzEgMTAwNjQ0Ci0tLSBhL3hlbi9pbmNsdWRlL3B1YmxpYy9tZW1vcnku aAorKysgYi94ZW4vaW5jbHVkZS9wdWJsaWMvbWVtb3J5LmgKQEAgLTY4LDYgKzY4LDggQEAgc3Ry dWN0IHhlbl9tZW1vcnlfcmVzZXJ2YXRpb24gewogICAgICAqICAgSU46ICBHUEZOIGJhc2VzIG9m IGV4dGVudHMgdG8gcG9wdWxhdGUgd2l0aCBtZW1vcnkKICAgICAgKiAgIE9VVDogR01GTiBiYXNl cyBvZiBleHRlbnRzIHRoYXQgd2VyZSBhbGxvY2F0ZWQKICAgICAgKiAgIChOQi4gVGhpcyBjb21t YW5kIGFsc28gdXBkYXRlcyB0aGUgbWFjaF90b19waHlzIHRyYW5zbGF0aW9uIHRhYmxlKQorICAg ICAqIFhFTk1FTV9jbGFpbV9wYWdlczoKKyAgICAgKiAgIElOOiBtdXN0IGJlIHplcm8KICAgICAg Ki8KICAgICBYRU5fR1VFU1RfSEFORExFKHhlbl9wZm5fdCkgZXh0ZW50X3N0YXJ0OwogCkBAIC00 MjEsNiArNDIzLDM1IEBAIHN0cnVjdCB4ZW5fbWVtX3NoYXJpbmdfb3AgewogdHlwZWRlZiBzdHJ1 Y3QgeGVuX21lbV9zaGFyaW5nX29wIHhlbl9tZW1fc2hhcmluZ19vcF90OwogREVGSU5FX1hFTl9H VUVTVF9IQU5ETEUoeGVuX21lbV9zaGFyaW5nX29wX3QpOwogCisvKgorICogQXR0ZW1wdCB0byBz dGFrZSBhIGNsYWltIGZvciBhIGRvbWFpbiBvbiBhIHF1YW50aXR5IG9mIHBhZ2VzCisgKiBvZiBz eXN0ZW0gUkFNLCBidXQgX25vdF8gYXNzaWduIHNwZWNpZmljIHBhZ2VmcmFtZXMuICBPbmx5Cisg KiBhcml0aG1ldGljIGlzIHBlcmZvcm1lZCBzbyB0aGUgaHlwZXJjYWxsIGlzIHZlcnkgZmFzdCBh bmQgbmVlZAorICogbm90IGJlIHByZWVtcHRpYmxlLCB0aHVzIHNpZGVzdGVwcGluZyB0aW1lLW9m LWNoZWNrLXRpbWUtb2YtdXNlCisgKiByYWNlcyBmb3IgbWVtb3J5IGFsbG9jYXRpb24uICBSZXR1 cm5zIDAgaWYgdGhlIGh5cGVydmlzb3IgcGFnZQorICogYWxsb2NhdG9yIGhhcyBhdG9taWNhbGx5 IGFuZCBzdWNjZXNzZnVsbHkgY2xhaW1lZCB0aGUgcmVxdWVzdGVkCisgKiBudW1iZXIgb2YgcGFn ZXMsIGVsc2Ugbm9uLXplcm8uCisgKgorICogQW55IGRvbWFpbiBtYXkgaGF2ZSBvbmx5IG9uZSBh Y3RpdmUgY2xhaW0uICBXaGVuIHN1ZmZpY2llbnQgbWVtb3J5CisgKiBoYXMgYmVlbiBhbGxvY2F0 ZWQgdG8gcmVzb2x2ZSB0aGUgY2xhaW0sIHRoZSBjbGFpbSBzaWxlbnRseSBleHBpcmVzLgorICog Q2xhaW1pbmcgemVybyBwYWdlcyBlZmZlY3RpdmVseSByZXNldHMgYW55IG91dHN0YW5kaW5nIGNs YWltIGFuZAorICogaXMgYWx3YXlzIHN1Y2Nlc3NmdWwuCisgKgorICogTm90ZSB0aGF0IGEgdmFs aWQgY2xhaW0gbWF5IGJlIHN0YWtlZCBldmVuIGFmdGVyIG1lbW9yeSBoYXMgYmVlbgorICogYWxs b2NhdGVkIGZvciBhIGRvbWFpbi4gIEluIHRoaXMgY2FzZSwgdGhlIGNsYWltIGlzIG5vdCBpbmNy ZW1lbnRhbCwKKyAqIGkuZS4gaWYgdGhlIGRvbWFpbidzIHRvdF9wYWdlcyBpcyAzLCBhbmQgYSBj bGFpbSBpcyBzdGFrZWQgZm9yIDEwLAorICogb25seSA3IGFkZGl0aW9uYWwgcGFnZXMgYXJlIGNs YWltZWQuCisgKi8KKyNkZWZpbmUgWEVOTUVNX2NsYWltX3BhZ2VzICAgICAgICAgICAgICAgICAg MjQKKy8qCisgKiBYRU5NRU1fY2xhaW1fcGFnZXMgZmxhZ3M6CisgKiAgZnJlZV9vbmx5OiBjbGFp bSBpcyBzdWNjZXNzZnVsIG9ubHkgaWYgc3VmZmljaWVudCBmcmVlIHBhZ2VzCisgKiAgICBhcmUg YXZhaWxhYmxlLiAgSWYgbm90IHNldCBhbmQgdG1lbSBpcyBlbmFibGVkLCBoeXBlcnZpc29yCisg KiAgICBtYXkgYWxzbyBjb25zaWRlciB0bWVtICJmcmVlYWJsZSIgcGFnZXMgdG8gc2F0aXNmeSB0 aGUgY2xhaW0uCisgKi8KKyNkZWZpbmUgX1hFTk1FTV9DTEFJTUZfZnJlZV9vbmx5ICAgICAgICAg ICAgMAorI2RlZmluZSBYRU5NRU1fQ0xBSU1GX2ZyZWVfb25seSAgICAgICAgICAgICAoMVU8PF9Y RU5NRU1fQ0xBSU1GX2ZyZWVfb25seSkKKwogI2VuZGlmIC8qIGRlZmluZWQoX19YRU5fXykgfHwg ZGVmaW5lZChfX1hFTl9UT09MU19fKSAqLwogCiAjZW5kaWYgLyogX19YRU5fUFVCTElDX01FTU9S WV9IX18gKi8KZGlmZiAtLWdpdCBhL3hlbi9pbmNsdWRlL3hlbi9tbS5oIGIveGVuL2luY2x1ZGUv eGVuL21tLmgKaW5kZXggNjRhMGNjMS4uNWM2MzU4MSAxMDA2NDQKLS0tIGEveGVuL2luY2x1ZGUv eGVuL21tLmgKKysrIGIveGVuL2luY2x1ZGUveGVuL21tLmgKQEAgLTQ4LDYgKzQ4LDEyIEBAIHZv aWQgZnJlZV94ZW5oZWFwX3BhZ2VzKHZvaWQgKnYsIHVuc2lnbmVkIGludCBvcmRlcik7CiAjZGVm aW5lIGFsbG9jX3hlbmhlYXBfcGFnZSgpIChhbGxvY194ZW5oZWFwX3BhZ2VzKDAsMCkpCiAjZGVm aW5lIGZyZWVfeGVuaGVhcF9wYWdlKHYpIChmcmVlX3hlbmhlYXBfcGFnZXModiwwKSkKIAorLyog Q2xhaW0gaGFuZGxpbmcgKi8KK3Vuc2lnbmVkIGxvbmcgZG9tYWluX2luY3JlYXNlX3RvdF9wYWdl cyhzdHJ1Y3QgZG9tYWluICpkLCB1bnNpZ25lZCBsb25nIHBhZ2VzKTsKK3Vuc2lnbmVkIGxvbmcg ZG9tYWluX2RlY3JlYXNlX3RvdF9wYWdlcyhzdHJ1Y3QgZG9tYWluICpkLCB1bnNpZ25lZCBsb25n IHBhZ2VzKTsKK2ludCBkb21haW5fc2V0X3VuY2xhaW1lZF9wYWdlcygKKyAgICBzdHJ1Y3QgZG9t YWluICpkLCB1bnNpZ25lZCBsb25nIHBhZ2VzLCB1bnNpZ25lZCBsb25nIGZsYWdzKTsKKwogLyog RG9tYWluIHN1YmFsbG9jYXRvci4gVGhlc2UgZnVuY3Rpb25zIGFyZSAqbm90KiBpbnRlcnJ1cHQt c2FmZS4qLwogdm9pZCBpbml0X2RvbWhlYXBfcGFnZXMocGFkZHJfdCBwcywgcGFkZHJfdCBwZSk7 CiBzdHJ1Y3QgcGFnZV9pbmZvICphbGxvY19kb21oZWFwX3BhZ2VzKApkaWZmIC0tZ2l0IGEveGVu L2luY2x1ZGUveGVuL3NjaGVkLmggYi94ZW4vaW5jbHVkZS94ZW4vc2NoZWQuaAppbmRleCA2YzU1 MDM5Li40ODBlZjM5IDEwMDY0NAotLS0gYS94ZW4vaW5jbHVkZS94ZW4vc2NoZWQuaAorKysgYi94 ZW4vaW5jbHVkZS94ZW4vc2NoZWQuaApAQCAtMjQyLDYgKzI0Miw3IEBAIHN0cnVjdCBkb21haW4K ICAgICBzdHJ1Y3QgcGFnZV9saXN0X2hlYWQgcGFnZV9saXN0OyAgLyogbGlua2VkIGxpc3QgKi8K ICAgICBzdHJ1Y3QgcGFnZV9saXN0X2hlYWQgeGVucGFnZV9saXN0OyAvKiBsaW5rZWQgbGlzdCAo c2l6ZSB4ZW5oZWFwX3BhZ2VzKSAqLwogICAgIHVuc2lnbmVkIGludCAgICAgdG90X3BhZ2VzOyAg ICAgICAvKiBudW1iZXIgb2YgcGFnZXMgY3VycmVudGx5IHBvc3Nlc2VkICovCisgICAgdW5zaWdu ZWQgaW50ICAgICB1bmNsYWltZWRfcGFnZXM7IC8qIHBhZ2VzIGNsYWltZWQgYnV0IG5vdCBwb3Nz ZXNzZWQgICAgKi8KICAgICB1bnNpZ25lZCBpbnQgICAgIG1heF9wYWdlczsgICAgICAgLyogbWF4 aW11bSB2YWx1ZSBmb3IgdG90X3BhZ2VzICAgICAgICAqLwogICAgIGF0b21pY190ICAgICAgICAg c2hyX3BhZ2VzOyAgICAgICAvKiBudW1iZXIgb2Ygc2hhcmVkIHBhZ2VzICAgICAgICAgICAgICov CiAgICAgYXRvbWljX3QgICAgICAgICBwYWdlZF9wYWdlczsgICAgIC8qIG51bWJlciBvZiBwYWdl ZC1vdXQgcGFnZXMgICAgICAgICAgKi8K --__1352937350095136424abhmt108.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 --__1352937350095136424abhmt108.oracle.com--