From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dario Faggioli Subject: [PATCHv2] Rework locking for sched_adjust. Date: Fri, 16 Dec 2011 17:53:44 +0100 Message-ID: <1324054424.2599.13.camel@Solace> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="===============0469156300206918351==" Return-path: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xensource.com Errors-To: xen-devel-bounces@lists.xensource.com To: "xen-devel@lists.xensource.com" Cc: George Dunlap , Juergen Gross , "Keir (Xen.org)" , Ian Campbell List-Id: xen-devel@lists.xenproject.org --===============0469156300206918351== Content-Type: multipart/signed; micalg="pgp-sha1"; protocol="application/pgp-signature"; boundary="=-s6aQxhtWfeniZORipy49" --=-s6aQxhtWfeniZORipy49 Content-Type: multipart/mixed; boundary="=-2gDoRwjHAIAVny3ceOG+" --=-2gDoRwjHAIAVny3ceOG+ Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable [Re-posting as the patch was damaged in the previous message] Hi everyone, Here it is v2 of the lock reworking around and within sched-adjust. With respect to the first posting [1]: - I _did_not_ move the per-pluggable scheduler lock toward schedule.c, as agreed with George during review; - I fixed the bug in sedf spotted by Juergen the way he suggested; - I've finally been able to test it under all the three schedulers,=20 and it is doing its job, at least here; Notice the series "collapsed" in one signle patch, as it was being hard to find a breakdown of it that does not introduce regressions and/or transient deadlock situations worse than the ones it's trying to cure... I hope it's still readable and comfortable to review. :-) Thanks to everyone who provided his feedback on the first version of this. Regards, Dario [1] http://xen.1045712.n5.nabble.com/RFC-RFT-PATCH-0-of-3-rework-locking-in-sch= ed-adjust-td5016899.html -- xen/common/sched_credit.c | 10 ++++++-- xen/common/sched_credit2.c | 21 ++++++++++--------- xen/common/sched_sedf.c | 156 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++= ++++++++++++++++++++++++++++++++++++++++++++-------------------------------= ---- xen/common/schedule.c | 34 +------------------------------- 4 files changed, 140 insertions(+), 81 deletions(-) -- # HG changeset patch # Parent 1452fb248cd513832cfbbd1100b9b72a0dde7ea6 Rework locking for sched_adjust. The main idea is to move (as much as possible) locking logic from generic code to the various pluggable schedulers. While at it, the following is also accomplished: - pausing all the non-current VCPUs of a domain while changing its scheduling parameters is not effective in avoiding races and it is prone to deadlock, so that is removed. - sedf needs a global lock for preventing races while adjusting domains' scheduling parameters (as it is for credit and credit2), so that is added. Signed-off-by: Dario Faggioli diff -r 1452fb248cd5 xen/common/sched_credit.c --- a/xen/common/sched_credit.c Fri Dec 16 15:45:40 2011 +0100 +++ b/xen/common/sched_credit.c Fri Dec 16 17:49:46 2011 +0100 @@ -161,6 +161,7 @@ struct csched_dom { * System-wide private data */ struct csched_private { + /* lock for the whole pluggable scheduler, nests inside cpupool_lock *= / spinlock_t lock; struct list_head active_sdom; uint32_t ncpus; @@ -800,6 +801,10 @@ csched_dom_cntl( struct csched_private *prv =3D CSCHED_PRIV(ops); unsigned long flags; =20 + /* Protect both get and put branches with the pluggable scheduler + * lock. Runq lock not needed anywhere in here. */ + spin_lock_irqsave(&prv->lock, flags); + if ( op->cmd =3D=3D XEN_DOMCTL_SCHEDOP_getinfo ) { op->u.credit.weight =3D sdom->weight; @@ -809,8 +814,6 @@ csched_dom_cntl( { ASSERT(op->cmd =3D=3D XEN_DOMCTL_SCHEDOP_putinfo); =20 - spin_lock_irqsave(&prv->lock, flags); - if ( op->u.credit.weight !=3D 0 ) { if ( !list_empty(&sdom->active_sdom_elem) ) @@ -824,9 +827,10 @@ csched_dom_cntl( if ( op->u.credit.cap !=3D (uint16_t)~0U ) sdom->cap =3D op->u.credit.cap; =20 - spin_unlock_irqrestore(&prv->lock, flags); } =20 + spin_unlock_irqrestore(&prv->lock, flags); + return 0; } =20 diff -r 1452fb248cd5 xen/common/sched_credit2.c --- a/xen/common/sched_credit2.c Fri Dec 16 15:45:40 2011 +0100 +++ b/xen/common/sched_credit2.c Fri Dec 16 17:49:46 2011 +0100 @@ -1384,6 +1384,10 @@ csched_dom_cntl( struct csched_private *prv =3D CSCHED_PRIV(ops); unsigned long flags; =20 + /* Must hold csched_priv lock to read and update sdom, + * runq lock to update csvcs. */ + spin_lock_irqsave(&prv->lock, flags); + if ( op->cmd =3D=3D XEN_DOMCTL_SCHEDOP_getinfo ) { op->u.credit2.weight =3D sdom->weight; @@ -1397,10 +1401,6 @@ csched_dom_cntl( struct list_head *iter; int old_weight; =20 - /* Must hold csched_priv lock to update sdom, runq lock to - * update csvcs. */ - spin_lock_irqsave(&prv->lock, flags); - old_weight =3D sdom->weight; =20 sdom->weight =3D op->u.credit2.weight; @@ -1411,22 +1411,23 @@ csched_dom_cntl( struct csched_vcpu *svc =3D list_entry(iter, struct csched= _vcpu, sdom_elem); =20 /* NB: Locking order is important here. Because we grab t= his lock here, we - * must never lock csched_priv.lock if we're holding a run= queue - * lock. */ - vcpu_schedule_lock_irq(svc->vcpu); + * must never lock csched_priv.lock if we're holding a run= queue lock. + * Also, calling vcpu_schedule_lock() is enough, since IRQ= s have already + * been disabled. */ + vcpu_schedule_lock(svc->vcpu); =20 BUG_ON(svc->rqd !=3D RQD(ops, svc->vcpu->processor)); =20 svc->weight =3D sdom->weight; update_max_weight(svc->rqd, svc->weight, old_weight); =20 - vcpu_schedule_unlock_irq(svc->vcpu); + vcpu_schedule_unlock(svc->vcpu); } - - spin_unlock_irqrestore(&prv->lock, flags); } } =20 + spin_unlock_irqrestore(&prv->lock, flags); + return 0; } =20 diff -r 1452fb248cd5 xen/common/sched_sedf.c --- a/xen/common/sched_sedf.c Fri Dec 16 15:45:40 2011 +0100 +++ b/xen/common/sched_sedf.c Fri Dec 16 17:49:46 2011 +0100 @@ -61,6 +61,11 @@ struct sedf_dom_info { struct domain *domain; }; =20 +struct sedf_priv_info { + /* lock for the whole pluggable scheduler, nests inside cpupool_lock *= / + spinlock_t lock; +}; + struct sedf_vcpu_info { struct vcpu *vcpu; struct list_head list; @@ -115,6 +120,8 @@ struct sedf_cpu_info { s_time_t current_slice_expires; }; =20 +#define SEDF_PRIV(_ops) \ + ((struct sedf_priv_info *)((_ops)->sched_data)) #define EDOM_INFO(d) ((struct sedf_vcpu_info *)((d)->sched_priv)) #define CPU_INFO(cpu) \ ((struct sedf_cpu_info *)per_cpu(schedule_data, cpu).sched_priv) @@ -772,6 +779,31 @@ static struct task_slice sedf_do_extra_s } =20 =20 +static int sedf_init(struct scheduler *ops) +{ + struct sedf_priv_info *prv; + + prv =3D xzalloc(struct sedf_priv_info); + if ( prv =3D=3D NULL ) + return -ENOMEM; + + ops->sched_data =3D prv; + spin_lock_init(&prv->lock); + + return 0; +} + + +static void sedf_deinit(const struct scheduler *ops) +{ + struct sedf_priv_info *prv; + + prv =3D SEDF_PRIV(ops); + if ( prv !=3D NULL ) + xfree(prv); +} + + /* Main scheduling function Reasons for calling this function are: -timeslice for the current period used up @@ -1320,22 +1352,15 @@ static void sedf_dump_cpu_state(const st =20 =20 /* Adjusts periods and slices of the domains accordingly to their weights.= */ -static int sedf_adjust_weights(struct cpupool *c, struct xen_domctl_schedu= ler_op *cmd) +static int sedf_adjust_weights(struct cpupool *c, int nr_cpus, int *sumw, = s_time_t *sumt) { struct vcpu *p; struct domain *d; - unsigned int cpu, nr_cpus =3D cpumask_last(&cpu_online_map) + 1= ; - int *sumw =3D xzalloc_array(int, nr_cpus); - s_time_t *sumt =3D xzalloc_array(s_time_t, nr_cpus); + unsigned int cpu; =20 - if ( !sumw || !sumt ) - { - xfree(sumt); - xfree(sumw); - return -ENOMEM; - } - - /* Sum across all weights. */ + /* Sum across all weights. Notice that no runq locking is needed + * here: the caller holds sedf_priv_info.lock and we're not changing + * anything that is accessed during scheduling. */ rcu_read_lock(&domlist_read_lock); for_each_domain_in_cpupool( d, c ) { @@ -1365,7 +1390,9 @@ static int sedf_adjust_weights(struct cp } rcu_read_unlock(&domlist_read_lock); =20 - /* Adjust all slices (and periods) to the new weight. */ + /* Adjust all slices (and periods) to the new weight. Unlike above, we + * need to take thr runq lock for the various VCPUs: we're modyfing + * slice and period which are referenced during scheduling. */ rcu_read_lock(&domlist_read_lock); for_each_domain_in_cpupool( d, c ) { @@ -1375,20 +1402,20 @@ static int sedf_adjust_weights(struct cp continue; if ( EDOM_INFO(p)->weight ) { + /* Interrupts already off */ + vcpu_schedule_lock(p); EDOM_INFO(p)->period_orig =3D=20 EDOM_INFO(p)->period =3D WEIGHT_PERIOD; EDOM_INFO(p)->slice_orig =3D EDOM_INFO(p)->slice =3D=20 (EDOM_INFO(p)->weight * (WEIGHT_PERIOD - WEIGHT_SAFETY - sumt[cpu])) / sumw[c= pu]; + vcpu_schedule_unlock(p); } } } rcu_read_unlock(&domlist_read_lock); =20 - xfree(sumt); - xfree(sumw); - return 0; } =20 @@ -1396,19 +1423,45 @@ static int sedf_adjust_weights(struct cp /* set or fetch domain scheduling parameters */ static int sedf_adjust(const struct scheduler *ops, struct domain *p, stru= ct xen_domctl_scheduler_op *op) { + struct sedf_priv_info *prv =3D SEDF_PRIV(ops); + unsigned long flags; + unsigned int nr_cpus =3D cpumask_last(&cpu_online_map) + 1; + int *sumw =3D xzalloc_array(int, nr_cpus); + s_time_t *sumt =3D xzalloc_array(s_time_t, nr_cpus); struct vcpu *v; - int rc; + int rc =3D 0; =20 PRINT(2,"sedf_adjust was called, domain-id %i new period %"PRIu64" " "new slice %"PRIu64"\nlatency %"PRIu64" extra:%s\n", p->domain_id, op->u.sedf.period, op->u.sedf.slice, op->u.sedf.latency, (op->u.sedf.extratime)?"yes":"no"); =20 + /* Serialize against the pluggable scheduler lock to protect from + * concurrent updates. We need to take the runq lock for the VCPUs + * as well, since we are touching extraweight, weight, slice and + * period. As in sched_credit2.c, runq locks nest inside the + * pluggable scheduler lock. */ + spin_lock_irqsave(&prv->lock, flags); + if ( op->cmd =3D=3D XEN_DOMCTL_SCHEDOP_putinfo ) { + /* These are used in sedf_adjust_weights() but have to be allocate= d in + * this function, as we need to avoid nesting xmem_pool_alloc's lo= ck + * within our prv->lock. */ + if ( !sumw || !sumt ) + { + /* Check for errors here, the _getinfo branch doesn't care */ + rc =3D -ENOMEM; + goto out; + } + /* Check for sane parameters. */ if ( !op->u.sedf.period && !op->u.sedf.weight ) - return -EINVAL; + { + rc =3D -EINVAL; + goto out; + } + if ( op->u.sedf.weight ) { if ( (op->u.sedf.extratime & EXTRA_AWARE) && @@ -1417,59 +1470,78 @@ static int sedf_adjust(const struct sche /* Weight-driven domains with extratime only. */ for_each_vcpu ( p, v ) { + /* (Here and everywhere in the following) IRQs are alr= eady off, + * hence vcpu_spin_lock() is the one. */ + vcpu_schedule_lock(v); EDOM_INFO(v)->extraweight =3D op->u.sedf.weight; EDOM_INFO(v)->weight =3D 0; EDOM_INFO(v)->slice =3D 0; EDOM_INFO(v)->period =3D WEIGHT_PERIOD; + vcpu_schedule_unlock(v); } } else { /* Weight-driven domains with real-time execution. */ - for_each_vcpu ( p, v ) + for_each_vcpu ( p, v ) { + vcpu_schedule_lock(v); EDOM_INFO(v)->weight =3D op->u.sedf.weight; + vcpu_schedule_unlock(v); + } } } else { + /* + * Sanity checking: note that disabling extra weight requires + * that we set a non-zero slice. + */ + if ( (op->u.sedf.period > PERIOD_MAX) || + (op->u.sedf.period < PERIOD_MIN) || + (op->u.sedf.slice > op->u.sedf.period) || + (op->u.sedf.slice < SLICE_MIN) ) + { + rc =3D -EINVAL; + goto out; + } + /* Time-driven domains. */ for_each_vcpu ( p, v ) { - /* - * Sanity checking: note that disabling extra weight requi= res - * that we set a non-zero slice. - */ - if ( (op->u.sedf.period > PERIOD_MAX) || - (op->u.sedf.period < PERIOD_MIN) || - (op->u.sedf.slice > op->u.sedf.period) || - (op->u.sedf.slice < SLICE_MIN) ) - return -EINVAL; + vcpu_schedule_lock(v); EDOM_INFO(v)->weight =3D 0; EDOM_INFO(v)->extraweight =3D 0; EDOM_INFO(v)->period_orig =3D=20 EDOM_INFO(v)->period =3D op->u.sedf.period; EDOM_INFO(v)->slice_orig =3D=20 EDOM_INFO(v)->slice =3D op->u.sedf.slice; + vcpu_schedule_unlock(v); } } =20 - rc =3D sedf_adjust_weights(p->cpupool, op); + rc =3D sedf_adjust_weights(p->cpupool, nr_cpus, sumw, sumt); if ( rc ) - return rc; + goto out; =20 for_each_vcpu ( p, v ) { + vcpu_schedule_lock(v); EDOM_INFO(v)->status =3D=20 (EDOM_INFO(v)->status & ~EXTRA_AWARE) | (op->u.sedf.extratime & EXTRA_AWARE); EDOM_INFO(v)->latency =3D op->u.sedf.latency; extraq_check(v); + vcpu_schedule_unlock(v); } } else if ( op->cmd =3D=3D XEN_DOMCTL_SCHEDOP_getinfo ) { if ( p->vcpu[0] =3D=3D NULL ) - return -EINVAL; + { + rc =3D -EINVAL; + goto out; + } + op->u.sedf.period =3D EDOM_INFO(p->vcpu[0])->period; op->u.sedf.slice =3D EDOM_INFO(p->vcpu[0])->slice; op->u.sedf.extratime =3D EDOM_INFO(p->vcpu[0])->status & EXTRA_AWA= RE; @@ -1477,14 +1549,23 @@ static int sedf_adjust(const struct sche op->u.sedf.weight =3D EDOM_INFO(p->vcpu[0])->weight; } =20 - PRINT(2,"sedf_adjust_finished\n"); - return 0; +out: + spin_unlock_irqrestore(&prv->lock, flags); + + xfree(sumt); + xfree(sumw); + + PRINT(2,"sedf_adjust_finished with return code %d\n", rc); + return rc; } =20 +static struct sedf_priv_info _sedf_priv; + const struct scheduler sched_sedf_def =3D { - .name =3D "Simple EDF Scheduler", - .opt_name =3D "sedf", - .sched_id =3D XEN_SCHEDULER_SEDF, + .name =3D "Simple EDF Scheduler", + .opt_name =3D "sedf", + .sched_id =3D XEN_SCHEDULER_SEDF, + .sched_data =3D &_sedf_priv, =20 .init_domain =3D sedf_init_domain, .destroy_domain =3D sedf_destroy_domain, @@ -1498,6 +1579,9 @@ const struct scheduler sched_sedf_def =3D=20 .alloc_domdata =3D sedf_alloc_domdata, .free_domdata =3D sedf_free_domdata, =20 + .init =3D sedf_init, + .deinit =3D sedf_deinit, + .do_schedule =3D sedf_do_schedule, .pick_cpu =3D sedf_pick_cpu, .dump_cpu_state =3D sedf_dump_cpu_state, diff -r 1452fb248cd5 xen/common/schedule.c --- a/xen/common/schedule.c Fri Dec 16 15:45:40 2011 +0100 +++ b/xen/common/schedule.c Fri Dec 16 17:49:46 2011 +0100 @@ -1005,7 +1005,6 @@ int sched_id(void) /* Adjust scheduling parameter for a given domain. */ long sched_adjust(struct domain *d, struct xen_domctl_scheduler_op *op) { - struct vcpu *v; long ret; =20 if ( (op->sched_id !=3D DOM2OP(d)->sched_id) || @@ -1013,40 +1012,11 @@ long sched_adjust(struct domain *d, stru (op->cmd !=3D XEN_DOMCTL_SCHEDOP_getinfo)) ) return -EINVAL; =20 - /* - * Most VCPUs we can simply pause. If we are adjusting this VCPU then - * we acquire the local schedule_lock to guard against concurrent upda= tes. - * - * We only acquire the local schedule lock after we have paused all ot= her - * VCPUs in this domain. There are two reasons for this: - * 1- We don't want to hold up interrupts as pausing a VCPU can - * trigger a tlb shootdown. - * 2- Pausing other VCPUs involves briefly locking the schedule - * lock of the CPU they are running on. This CPU could be the - * same as ours. - */ - - for_each_vcpu ( d, v ) - { - if ( v !=3D current ) - vcpu_pause(v); - } - - if ( d =3D=3D current->domain ) - vcpu_schedule_lock_irq(current); - + /* NB: the pluggable scheduler code needs to take care + * of locking by itself. */ if ( (ret =3D SCHED_OP(DOM2OP(d), adjust, d, op)) =3D=3D 0 ) TRACE_1D(TRC_SCHED_ADJDOM, d->domain_id); =20 - if ( d =3D=3D current->domain ) - vcpu_schedule_unlock_irq(current); - - for_each_vcpu ( d, v ) - { - if ( v !=3D current ) - vcpu_unpause(v); - } - return ret; } =20 --=20 <> (Raistlin Majere) ------------------------------------------------------------------- Dario Faggioli, http://retis.sssup.it/people/faggioli Senior Software Engineer, Citrix Systems R&D Ltd., Cambridge (UK) PhD Candidate, ReTiS Lab, Scuola Superiore Sant'Anna, Pisa (Italy) --=-2gDoRwjHAIAVny3ceOG+ Content-Disposition: attachment; filename="rework-locking-for-sched-adjust.patch" Content-Transfer-Encoding: base64 Content-Type: text/x-patch; name="rework-locking-for-sched-adjust.patch"; charset="UTF-8" IyBIRyBjaGFuZ2VzZXQgcGF0Y2gNCiMgUGFyZW50IDE0NTJmYjI0OGNkNTEzODMyY2ZiYmQxMTAw YjliNzJhMGRkZTdlYTYNClJld29yayBsb2NraW5nIGZvciBzY2hlZF9hZGp1c3QuDQoNClRoZSBt YWluIGlkZWEgaXMgdG8gbW92ZSAoYXMgbXVjaCBhcyBwb3NzaWJsZSkgbG9ja2luZyBsb2dpYw0K ZnJvbSBnZW5lcmljIGNvZGUgdG8gdGhlIHZhcmlvdXMgcGx1Z2dhYmxlIHNjaGVkdWxlcnMuDQoN CldoaWxlIGF0IGl0LCB0aGUgZm9sbG93aW5nIGlzIGFsc28gYWNjb21wbGlzaGVkOg0KIC0gcGF1 c2luZyBhbGwgdGhlIG5vbi1jdXJyZW50IFZDUFVzIG9mIGEgZG9tYWluIHdoaWxlIGNoYW5naW5n IGl0cw0KICAgc2NoZWR1bGluZyBwYXJhbWV0ZXJzIGlzIG5vdCBlZmZlY3RpdmUgaW4gYXZvaWRp bmcgcmFjZXMgYW5kIGl0IGlzDQogICBwcm9uZSB0byBkZWFkbG9jaywgc28gdGhhdCBpcyByZW1v dmVkLg0KIC0gc2VkZiBuZWVkcyBhIGdsb2JhbCBsb2NrIGZvciBwcmV2ZW50aW5nIHJhY2VzIHdo aWxlIGFkanVzdGluZw0KICAgZG9tYWlucycgc2NoZWR1bGluZyBwYXJhbWV0ZXJzIChhcyBpdCBp cyBmb3IgY3JlZGl0IGFuZCBjcmVkaXQyKSwNCiAgIHNvIHRoYXQgaXMgYWRkZWQuDQoNClNpZ25l ZC1vZmYtYnk6IERhcmlvIEZhZ2dpb2xpIDxkYXJpby5mYWdnaW9saUBjaXRyaXguY29tPg0KDQpk aWZmIC1yIDE0NTJmYjI0OGNkNSB4ZW4vY29tbW9uL3NjaGVkX2NyZWRpdC5jDQotLS0gYS94ZW4v Y29tbW9uL3NjaGVkX2NyZWRpdC5jCUZyaSBEZWMgMTYgMTU6NDU6NDAgMjAxMSArMDEwMA0KKysr IGIveGVuL2NvbW1vbi9zY2hlZF9jcmVkaXQuYwlGcmkgRGVjIDE2IDE3OjQ5OjQ2IDIwMTEgKzAx MDANCkBAIC0xNjEsNiArMTYxLDcgQEAgc3RydWN0IGNzY2hlZF9kb20gew0KICAqIFN5c3RlbS13 aWRlIHByaXZhdGUgZGF0YQ0KICAqLw0KIHN0cnVjdCBjc2NoZWRfcHJpdmF0ZSB7DQorICAgIC8q IGxvY2sgZm9yIHRoZSB3aG9sZSBwbHVnZ2FibGUgc2NoZWR1bGVyLCBuZXN0cyBpbnNpZGUgY3B1 cG9vbF9sb2NrICovDQogICAgIHNwaW5sb2NrX3QgbG9jazsNCiAgICAgc3RydWN0IGxpc3RfaGVh ZCBhY3RpdmVfc2RvbTsNCiAgICAgdWludDMyX3QgbmNwdXM7DQpAQCAtODAwLDYgKzgwMSwxMCBA QCBjc2NoZWRfZG9tX2NudGwoDQogICAgIHN0cnVjdCBjc2NoZWRfcHJpdmF0ZSAqcHJ2ID0gQ1ND SEVEX1BSSVYob3BzKTsNCiAgICAgdW5zaWduZWQgbG9uZyBmbGFnczsNCiANCisgICAgLyogUHJv dGVjdCBib3RoIGdldCBhbmQgcHV0IGJyYW5jaGVzIHdpdGggdGhlIHBsdWdnYWJsZSBzY2hlZHVs ZXINCisgICAgICogbG9jay4gUnVucSBsb2NrIG5vdCBuZWVkZWQgYW55d2hlcmUgaW4gaGVyZS4g Ki8NCisgICAgc3Bpbl9sb2NrX2lycXNhdmUoJnBydi0+bG9jaywgZmxhZ3MpOw0KKw0KICAgICBp ZiAoIG9wLT5jbWQgPT0gWEVOX0RPTUNUTF9TQ0hFRE9QX2dldGluZm8gKQ0KICAgICB7DQogICAg ICAgICBvcC0+dS5jcmVkaXQud2VpZ2h0ID0gc2RvbS0+d2VpZ2h0Ow0KQEAgLTgwOSw4ICs4MTQs NiBAQCBjc2NoZWRfZG9tX2NudGwoDQogICAgIHsNCiAgICAgICAgIEFTU0VSVChvcC0+Y21kID09 IFhFTl9ET01DVExfU0NIRURPUF9wdXRpbmZvKTsNCiANCi0gICAgICAgIHNwaW5fbG9ja19pcnFz YXZlKCZwcnYtPmxvY2ssIGZsYWdzKTsNCi0NCiAgICAgICAgIGlmICggb3AtPnUuY3JlZGl0Lndl aWdodCAhPSAwICkNCiAgICAgICAgIHsNCiAgICAgICAgICAgICBpZiAoICFsaXN0X2VtcHR5KCZz ZG9tLT5hY3RpdmVfc2RvbV9lbGVtKSApDQpAQCAtODI0LDkgKzgyNywxMCBAQCBjc2NoZWRfZG9t X2NudGwoDQogICAgICAgICBpZiAoIG9wLT51LmNyZWRpdC5jYXAgIT0gKHVpbnQxNl90KX4wVSAp DQogICAgICAgICAgICAgc2RvbS0+Y2FwID0gb3AtPnUuY3JlZGl0LmNhcDsNCiANCi0gICAgICAg IHNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBydi0+bG9jaywgZmxhZ3MpOw0KICAgICB9DQogDQor ICAgIHNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBydi0+bG9jaywgZmxhZ3MpOw0KKw0KICAgICBy ZXR1cm4gMDsNCiB9DQogDQpkaWZmIC1yIDE0NTJmYjI0OGNkNSB4ZW4vY29tbW9uL3NjaGVkX2Ny ZWRpdDIuYw0KLS0tIGEveGVuL2NvbW1vbi9zY2hlZF9jcmVkaXQyLmMJRnJpIERlYyAxNiAxNTo0 NTo0MCAyMDExICswMTAwDQorKysgYi94ZW4vY29tbW9uL3NjaGVkX2NyZWRpdDIuYwlGcmkgRGVj IDE2IDE3OjQ5OjQ2IDIwMTEgKzAxMDANCkBAIC0xMzg0LDYgKzEzODQsMTAgQEAgY3NjaGVkX2Rv bV9jbnRsKA0KICAgICBzdHJ1Y3QgY3NjaGVkX3ByaXZhdGUgKnBydiA9IENTQ0hFRF9QUklWKG9w cyk7DQogICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7DQogDQorICAgIC8qIE11c3QgaG9sZCBjc2No ZWRfcHJpdiBsb2NrIHRvIHJlYWQgYW5kIHVwZGF0ZSBzZG9tLA0KKyAgICAgKiBydW5xIGxvY2sg dG8gdXBkYXRlIGNzdmNzLiAqLw0KKyAgICBzcGluX2xvY2tfaXJxc2F2ZSgmcHJ2LT5sb2NrLCBm bGFncyk7DQorDQogICAgIGlmICggb3AtPmNtZCA9PSBYRU5fRE9NQ1RMX1NDSEVET1BfZ2V0aW5m byApDQogICAgIHsNCiAgICAgICAgIG9wLT51LmNyZWRpdDIud2VpZ2h0ID0gc2RvbS0+d2VpZ2h0 Ow0KQEAgLTEzOTcsMTAgKzE0MDEsNiBAQCBjc2NoZWRfZG9tX2NudGwoDQogICAgICAgICAgICAg c3RydWN0IGxpc3RfaGVhZCAqaXRlcjsNCiAgICAgICAgICAgICBpbnQgb2xkX3dlaWdodDsNCiAN Ci0gICAgICAgICAgICAvKiBNdXN0IGhvbGQgY3NjaGVkX3ByaXYgbG9jayB0byB1cGRhdGUgc2Rv bSwgcnVucSBsb2NrIHRvDQotICAgICAgICAgICAgICogdXBkYXRlIGNzdmNzLiAqLw0KLSAgICAg ICAgICAgIHNwaW5fbG9ja19pcnFzYXZlKCZwcnYtPmxvY2ssIGZsYWdzKTsNCi0NCiAgICAgICAg ICAgICBvbGRfd2VpZ2h0ID0gc2RvbS0+d2VpZ2h0Ow0KIA0KICAgICAgICAgICAgIHNkb20tPndl aWdodCA9IG9wLT51LmNyZWRpdDIud2VpZ2h0Ow0KQEAgLTE0MTEsMjIgKzE0MTEsMjMgQEAgY3Nj aGVkX2RvbV9jbnRsKA0KICAgICAgICAgICAgICAgICBzdHJ1Y3QgY3NjaGVkX3ZjcHUgKnN2YyA9 IGxpc3RfZW50cnkoaXRlciwgc3RydWN0IGNzY2hlZF92Y3B1LCBzZG9tX2VsZW0pOw0KIA0KICAg ICAgICAgICAgICAgICAvKiBOQjogTG9ja2luZyBvcmRlciBpcyBpbXBvcnRhbnQgaGVyZS4gIEJl Y2F1c2Ugd2UgZ3JhYiB0aGlzIGxvY2sgaGVyZSwgd2UNCi0gICAgICAgICAgICAgICAgICogbXVz dCBuZXZlciBsb2NrIGNzY2hlZF9wcml2LmxvY2sgaWYgd2UncmUgaG9sZGluZyBhIHJ1bnF1ZXVl DQotICAgICAgICAgICAgICAgICAqIGxvY2suICovDQotICAgICAgICAgICAgICAgIHZjcHVfc2No ZWR1bGVfbG9ja19pcnEoc3ZjLT52Y3B1KTsNCisgICAgICAgICAgICAgICAgICogbXVzdCBuZXZl ciBsb2NrIGNzY2hlZF9wcml2LmxvY2sgaWYgd2UncmUgaG9sZGluZyBhIHJ1bnF1ZXVlIGxvY2su DQorICAgICAgICAgICAgICAgICAqIEFsc28sIGNhbGxpbmcgdmNwdV9zY2hlZHVsZV9sb2NrKCkg aXMgZW5vdWdoLCBzaW5jZSBJUlFzIGhhdmUgYWxyZWFkeQ0KKyAgICAgICAgICAgICAgICAgKiBi ZWVuIGRpc2FibGVkLiAqLw0KKyAgICAgICAgICAgICAgICB2Y3B1X3NjaGVkdWxlX2xvY2soc3Zj LT52Y3B1KTsNCiANCiAgICAgICAgICAgICAgICAgQlVHX09OKHN2Yy0+cnFkICE9IFJRRChvcHMs IHN2Yy0+dmNwdS0+cHJvY2Vzc29yKSk7DQogDQogICAgICAgICAgICAgICAgIHN2Yy0+d2VpZ2h0 ID0gc2RvbS0+d2VpZ2h0Ow0KICAgICAgICAgICAgICAgICB1cGRhdGVfbWF4X3dlaWdodChzdmMt PnJxZCwgc3ZjLT53ZWlnaHQsIG9sZF93ZWlnaHQpOw0KIA0KLSAgICAgICAgICAgICAgICB2Y3B1 X3NjaGVkdWxlX3VubG9ja19pcnEoc3ZjLT52Y3B1KTsNCisgICAgICAgICAgICAgICAgdmNwdV9z Y2hlZHVsZV91bmxvY2soc3ZjLT52Y3B1KTsNCiAgICAgICAgICAgICB9DQotDQotICAgICAgICAg ICAgc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJ2LT5sb2NrLCBmbGFncyk7DQogICAgICAgICB9 DQogICAgIH0NCiANCisgICAgc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJ2LT5sb2NrLCBmbGFn cyk7DQorDQogICAgIHJldHVybiAwOw0KIH0NCiANCmRpZmYgLXIgMTQ1MmZiMjQ4Y2Q1IHhlbi9j b21tb24vc2NoZWRfc2VkZi5jDQotLS0gYS94ZW4vY29tbW9uL3NjaGVkX3NlZGYuYwlGcmkgRGVj IDE2IDE1OjQ1OjQwIDIwMTEgKzAxMDANCisrKyBiL3hlbi9jb21tb24vc2NoZWRfc2VkZi5jCUZy aSBEZWMgMTYgMTc6NDk6NDYgMjAxMSArMDEwMA0KQEAgLTYxLDYgKzYxLDExIEBAIHN0cnVjdCBz ZWRmX2RvbV9pbmZvIHsNCiAgICAgc3RydWN0IGRvbWFpbiAgKmRvbWFpbjsNCiB9Ow0KIA0KK3N0 cnVjdCBzZWRmX3ByaXZfaW5mbyB7DQorICAgIC8qIGxvY2sgZm9yIHRoZSB3aG9sZSBwbHVnZ2Fi bGUgc2NoZWR1bGVyLCBuZXN0cyBpbnNpZGUgY3B1cG9vbF9sb2NrICovDQorICAgIHNwaW5sb2Nr X3QgbG9jazsNCit9Ow0KKw0KIHN0cnVjdCBzZWRmX3ZjcHVfaW5mbyB7DQogICAgIHN0cnVjdCB2 Y3B1ICp2Y3B1Ow0KICAgICBzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7DQpAQCAtMTE1LDYgKzEyMCw4 IEBAIHN0cnVjdCBzZWRmX2NwdV9pbmZvIHsNCiAgICAgc190aW1lX3QgICAgICAgICBjdXJyZW50 X3NsaWNlX2V4cGlyZXM7DQogfTsNCiANCisjZGVmaW5lIFNFREZfUFJJVihfb3BzKSBcDQorICAg ICgoc3RydWN0IHNlZGZfcHJpdl9pbmZvICopKChfb3BzKS0+c2NoZWRfZGF0YSkpDQogI2RlZmlu ZSBFRE9NX0lORk8oZCkgICAoKHN0cnVjdCBzZWRmX3ZjcHVfaW5mbyAqKSgoZCktPnNjaGVkX3By aXYpKQ0KICNkZWZpbmUgQ1BVX0lORk8oY3B1KSAgXA0KICAgICAoKHN0cnVjdCBzZWRmX2NwdV9p bmZvICopcGVyX2NwdShzY2hlZHVsZV9kYXRhLCBjcHUpLnNjaGVkX3ByaXYpDQpAQCAtNzcyLDYg Kzc3OSwzMSBAQCBzdGF0aWMgc3RydWN0IHRhc2tfc2xpY2Ugc2VkZl9kb19leHRyYV9zDQogfQ0K IA0KIA0KK3N0YXRpYyBpbnQgc2VkZl9pbml0KHN0cnVjdCBzY2hlZHVsZXIgKm9wcykNCit7DQor ICAgIHN0cnVjdCBzZWRmX3ByaXZfaW5mbyAqcHJ2Ow0KKw0KKyAgICBwcnYgPSB4emFsbG9jKHN0 cnVjdCBzZWRmX3ByaXZfaW5mbyk7DQorICAgIGlmICggcHJ2ID09IE5VTEwgKQ0KKyAgICAgICAg cmV0dXJuIC1FTk9NRU07DQorDQorICAgIG9wcy0+c2NoZWRfZGF0YSA9IHBydjsNCisgICAgc3Bp bl9sb2NrX2luaXQoJnBydi0+bG9jayk7DQorDQorICAgIHJldHVybiAwOw0KK30NCisNCisNCitz dGF0aWMgdm9pZCBzZWRmX2RlaW5pdChjb25zdCBzdHJ1Y3Qgc2NoZWR1bGVyICpvcHMpDQorew0K KyAgICBzdHJ1Y3Qgc2VkZl9wcml2X2luZm8gKnBydjsNCisNCisgICAgcHJ2ID0gU0VERl9QUklW KG9wcyk7DQorICAgIGlmICggcHJ2ICE9IE5VTEwgKQ0KKyAgICAgICAgeGZyZWUocHJ2KTsNCit9 DQorDQorDQogLyogTWFpbiBzY2hlZHVsaW5nIGZ1bmN0aW9uDQogICAgUmVhc29ucyBmb3IgY2Fs bGluZyB0aGlzIGZ1bmN0aW9uIGFyZToNCiAgICAtdGltZXNsaWNlIGZvciB0aGUgY3VycmVudCBw ZXJpb2QgdXNlZCB1cA0KQEAgLTEzMjAsMjIgKzEzNTIsMTUgQEAgc3RhdGljIHZvaWQgc2VkZl9k dW1wX2NwdV9zdGF0ZShjb25zdCBzdA0KIA0KIA0KIC8qIEFkanVzdHMgcGVyaW9kcyBhbmQgc2xp Y2VzIG9mIHRoZSBkb21haW5zIGFjY29yZGluZ2x5IHRvIHRoZWlyIHdlaWdodHMuICovDQotc3Rh dGljIGludCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBjcHVwb29sICpjLCBzdHJ1Y3QgeGVu X2RvbWN0bF9zY2hlZHVsZXJfb3AgKmNtZCkNCitzdGF0aWMgaW50IHNlZGZfYWRqdXN0X3dlaWdo dHMoc3RydWN0IGNwdXBvb2wgKmMsIGludCBucl9jcHVzLCBpbnQgKnN1bXcsIHNfdGltZV90ICpz dW10KQ0KIHsNCiAgICAgc3RydWN0IHZjcHUgKnA7DQogICAgIHN0cnVjdCBkb21haW4gICAgICAq ZDsNCi0gICAgdW5zaWduZWQgaW50ICAgICAgICBjcHUsIG5yX2NwdXMgPSBjcHVtYXNrX2xhc3Qo JmNwdV9vbmxpbmVfbWFwKSArIDE7DQotICAgIGludCAgICAgICAgICAgICAgICAqc3VtdyA9IHh6 YWxsb2NfYXJyYXkoaW50LCBucl9jcHVzKTsNCi0gICAgc190aW1lX3QgICAgICAgICAgICpzdW10 ID0geHphbGxvY19hcnJheShzX3RpbWVfdCwgbnJfY3B1cyk7DQorICAgIHVuc2lnbmVkIGludCAg ICAgICAgY3B1Ow0KIA0KLSAgICBpZiAoICFzdW13IHx8ICFzdW10ICkNCi0gICAgew0KLSAgICAg ICAgeGZyZWUoc3VtdCk7DQotICAgICAgICB4ZnJlZShzdW13KTsNCi0gICAgICAgIHJldHVybiAt RU5PTUVNOw0KLSAgICB9DQotDQotICAgIC8qIFN1bSBhY3Jvc3MgYWxsIHdlaWdodHMuICovDQor ICAgIC8qIFN1bSBhY3Jvc3MgYWxsIHdlaWdodHMuIE5vdGljZSB0aGF0IG5vIHJ1bnEgbG9ja2lu ZyBpcyBuZWVkZWQNCisgICAgICogaGVyZTogdGhlIGNhbGxlciBob2xkcyBzZWRmX3ByaXZfaW5m by5sb2NrIGFuZCB3ZSdyZSBub3QgY2hhbmdpbmcNCisgICAgICogYW55dGhpbmcgdGhhdCBpcyBh Y2Nlc3NlZCBkdXJpbmcgc2NoZWR1bGluZy4gKi8NCiAgICAgcmN1X3JlYWRfbG9jaygmZG9tbGlz dF9yZWFkX2xvY2spOw0KICAgICBmb3JfZWFjaF9kb21haW5faW5fY3B1cG9vbCggZCwgYyApDQog ICAgIHsNCkBAIC0xMzY1LDcgKzEzOTAsOSBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0X3dlaWdo dHMoc3RydWN0IGNwDQogICAgIH0NCiAgICAgcmN1X3JlYWRfdW5sb2NrKCZkb21saXN0X3JlYWRf bG9jayk7DQogDQotICAgIC8qIEFkanVzdCBhbGwgc2xpY2VzIChhbmQgcGVyaW9kcykgdG8gdGhl IG5ldyB3ZWlnaHQuICovDQorICAgIC8qIEFkanVzdCBhbGwgc2xpY2VzIChhbmQgcGVyaW9kcykg dG8gdGhlIG5ldyB3ZWlnaHQuIFVubGlrZSBhYm92ZSwgd2UNCisgICAgICogbmVlZCB0byB0YWtl IHRociBydW5xIGxvY2sgZm9yIHRoZSB2YXJpb3VzIFZDUFVzOiB3ZSdyZSBtb2R5ZmluZw0KKyAg ICAgKiBzbGljZSBhbmQgcGVyaW9kIHdoaWNoIGFyZSByZWZlcmVuY2VkIGR1cmluZyBzY2hlZHVs aW5nLiAqLw0KICAgICByY3VfcmVhZF9sb2NrKCZkb21saXN0X3JlYWRfbG9jayk7DQogICAgIGZv cl9lYWNoX2RvbWFpbl9pbl9jcHVwb29sKCBkLCBjICkNCiAgICAgew0KQEAgLTEzNzUsMjAgKzE0 MDIsMjAgQEAgc3RhdGljIGludCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBjcA0KICAgICAg ICAgICAgICAgICBjb250aW51ZTsNCiAgICAgICAgICAgICBpZiAoIEVET01fSU5GTyhwKS0+d2Vp Z2h0ICkNCiAgICAgICAgICAgICB7DQorICAgICAgICAgICAgICAgIC8qIEludGVycnVwdHMgYWxy ZWFkeSBvZmYgKi8NCisgICAgICAgICAgICAgICAgdmNwdV9zY2hlZHVsZV9sb2NrKHApOw0KICAg ICAgICAgICAgICAgICBFRE9NX0lORk8ocCktPnBlcmlvZF9vcmlnID0gDQogICAgICAgICAgICAg ICAgICAgICBFRE9NX0lORk8ocCktPnBlcmlvZCAgPSBXRUlHSFRfUEVSSU9EOw0KICAgICAgICAg ICAgICAgICBFRE9NX0lORk8ocCktPnNsaWNlX29yaWcgID0NCiAgICAgICAgICAgICAgICAgICAg IEVET01fSU5GTyhwKS0+c2xpY2UgICA9IA0KICAgICAgICAgICAgICAgICAgICAgKEVET01fSU5G TyhwKS0+d2VpZ2h0ICoNCiAgICAgICAgICAgICAgICAgICAgICAoV0VJR0hUX1BFUklPRCAtIFdF SUdIVF9TQUZFVFkgLSBzdW10W2NwdV0pKSAvIHN1bXdbY3B1XTsNCisgICAgICAgICAgICAgICAg dmNwdV9zY2hlZHVsZV91bmxvY2socCk7DQogICAgICAgICAgICAgfQ0KICAgICAgICAgfQ0KICAg ICB9DQogICAgIHJjdV9yZWFkX3VubG9jaygmZG9tbGlzdF9yZWFkX2xvY2spOw0KIA0KLSAgICB4 ZnJlZShzdW10KTsNCi0gICAgeGZyZWUoc3Vtdyk7DQotDQogICAgIHJldHVybiAwOw0KIH0NCiAN CkBAIC0xMzk2LDE5ICsxNDIzLDQ1IEBAIHN0YXRpYyBpbnQgc2VkZl9hZGp1c3Rfd2VpZ2h0cyhz dHJ1Y3QgY3ANCiAvKiBzZXQgb3IgZmV0Y2ggZG9tYWluIHNjaGVkdWxpbmcgcGFyYW1ldGVycyAq Lw0KIHN0YXRpYyBpbnQgc2VkZl9hZGp1c3QoY29uc3Qgc3RydWN0IHNjaGVkdWxlciAqb3BzLCBz dHJ1Y3QgZG9tYWluICpwLCBzdHJ1Y3QgeGVuX2RvbWN0bF9zY2hlZHVsZXJfb3AgKm9wKQ0KIHsN CisgICAgc3RydWN0IHNlZGZfcHJpdl9pbmZvICpwcnYgPSBTRURGX1BSSVYob3BzKTsNCisgICAg dW5zaWduZWQgbG9uZyBmbGFnczsNCisgICAgdW5zaWduZWQgaW50IG5yX2NwdXMgPSBjcHVtYXNr X2xhc3QoJmNwdV9vbmxpbmVfbWFwKSArIDE7DQorICAgIGludCAqc3VtdyA9IHh6YWxsb2NfYXJy YXkoaW50LCBucl9jcHVzKTsNCisgICAgc190aW1lX3QgKnN1bXQgPSB4emFsbG9jX2FycmF5KHNf dGltZV90LCBucl9jcHVzKTsNCiAgICAgc3RydWN0IHZjcHUgKnY7DQotICAgIGludCByYzsNCisg ICAgaW50IHJjID0gMDsNCiANCiAgICAgUFJJTlQoMiwic2VkZl9hZGp1c3Qgd2FzIGNhbGxlZCwg ZG9tYWluLWlkICVpIG5ldyBwZXJpb2QgJSJQUkl1NjQiICINCiAgICAgICAgICAgIm5ldyBzbGlj ZSAlIlBSSXU2NCJcbmxhdGVuY3kgJSJQUkl1NjQiIGV4dHJhOiVzXG4iLA0KICAgICAgICAgICBw LT5kb21haW5faWQsIG9wLT51LnNlZGYucGVyaW9kLCBvcC0+dS5zZWRmLnNsaWNlLA0KICAgICAg ICAgICBvcC0+dS5zZWRmLmxhdGVuY3ksIChvcC0+dS5zZWRmLmV4dHJhdGltZSk/InllcyI6Im5v Iik7DQogDQorICAgIC8qIFNlcmlhbGl6ZSBhZ2FpbnN0IHRoZSBwbHVnZ2FibGUgc2NoZWR1bGVy IGxvY2sgdG8gcHJvdGVjdCBmcm9tDQorICAgICAqIGNvbmN1cnJlbnQgdXBkYXRlcy4gV2UgbmVl ZCB0byB0YWtlIHRoZSBydW5xIGxvY2sgZm9yIHRoZSBWQ1BVcw0KKyAgICAgKiBhcyB3ZWxsLCBz aW5jZSB3ZSBhcmUgdG91Y2hpbmcgZXh0cmF3ZWlnaHQsIHdlaWdodCwgc2xpY2UgYW5kDQorICAg ICAqIHBlcmlvZC4gQXMgaW4gc2NoZWRfY3JlZGl0Mi5jLCBydW5xIGxvY2tzIG5lc3QgaW5zaWRl IHRoZQ0KKyAgICAgKiBwbHVnZ2FibGUgc2NoZWR1bGVyIGxvY2suICovDQorICAgIHNwaW5fbG9j a19pcnFzYXZlKCZwcnYtPmxvY2ssIGZsYWdzKTsNCisNCiAgICAgaWYgKCBvcC0+Y21kID09IFhF Tl9ET01DVExfU0NIRURPUF9wdXRpbmZvICkNCiAgICAgew0KKyAgICAgICAgLyogVGhlc2UgYXJl IHVzZWQgaW4gc2VkZl9hZGp1c3Rfd2VpZ2h0cygpIGJ1dCBoYXZlIHRvIGJlIGFsbG9jYXRlZCBp bg0KKyAgICAgICAgICogdGhpcyBmdW5jdGlvbiwgYXMgd2UgbmVlZCB0byBhdm9pZCBuZXN0aW5n IHhtZW1fcG9vbF9hbGxvYydzIGxvY2sNCisgICAgICAgICAqIHdpdGhpbiBvdXIgcHJ2LT5sb2Nr LiAqLw0KKyAgICAgICAgaWYgKCAhc3VtdyB8fCAhc3VtdCApDQorICAgICAgICB7DQorICAgICAg ICAgICAgLyogQ2hlY2sgZm9yIGVycm9ycyBoZXJlLCB0aGUgX2dldGluZm8gYnJhbmNoIGRvZXNu J3QgY2FyZSAqLw0KKyAgICAgICAgICAgIHJjID0gLUVOT01FTTsNCisgICAgICAgICAgICBnb3Rv IG91dDsNCisgICAgICAgIH0NCisNCiAgICAgICAgIC8qIENoZWNrIGZvciBzYW5lIHBhcmFtZXRl cnMuICovDQogICAgICAgICBpZiAoICFvcC0+dS5zZWRmLnBlcmlvZCAmJiAhb3AtPnUuc2VkZi53 ZWlnaHQgKQ0KLSAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOw0KKyAgICAgICAgew0KKyAgICAg ICAgICAgIHJjID0gLUVJTlZBTDsNCisgICAgICAgICAgICBnb3RvIG91dDsNCisgICAgICAgIH0N CisNCiAgICAgICAgIGlmICggb3AtPnUuc2VkZi53ZWlnaHQgKQ0KICAgICAgICAgew0KICAgICAg ICAgICAgIGlmICggKG9wLT51LnNlZGYuZXh0cmF0aW1lICYgRVhUUkFfQVdBUkUpICYmDQpAQCAt MTQxNyw1OSArMTQ3MCw3OCBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBz Y2hlDQogICAgICAgICAgICAgICAgIC8qIFdlaWdodC1kcml2ZW4gZG9tYWlucyB3aXRoIGV4dHJh dGltZSBvbmx5LiAqLw0KICAgICAgICAgICAgICAgICBmb3JfZWFjaF92Y3B1ICggcCwgdiApDQog ICAgICAgICAgICAgICAgIHsNCisgICAgICAgICAgICAgICAgICAgIC8qIChIZXJlIGFuZCBldmVy eXdoZXJlIGluIHRoZSBmb2xsb3dpbmcpIElSUXMgYXJlIGFscmVhZHkgb2ZmLA0KKyAgICAgICAg ICAgICAgICAgICAgICogaGVuY2UgdmNwdV9zcGluX2xvY2soKSBpcyB0aGUgb25lLiAqLw0KKyAg ICAgICAgICAgICAgICAgICAgdmNwdV9zY2hlZHVsZV9sb2NrKHYpOw0KICAgICAgICAgICAgICAg ICAgICAgRURPTV9JTkZPKHYpLT5leHRyYXdlaWdodCA9IG9wLT51LnNlZGYud2VpZ2h0Ow0KICAg ICAgICAgICAgICAgICAgICAgRURPTV9JTkZPKHYpLT53ZWlnaHQgPSAwOw0KICAgICAgICAgICAg ICAgICAgICAgRURPTV9JTkZPKHYpLT5zbGljZSA9IDA7DQogICAgICAgICAgICAgICAgICAgICBF RE9NX0lORk8odiktPnBlcmlvZCA9IFdFSUdIVF9QRVJJT0Q7DQorICAgICAgICAgICAgICAgICAg ICB2Y3B1X3NjaGVkdWxlX3VubG9jayh2KTsNCiAgICAgICAgICAgICAgICAgfQ0KICAgICAgICAg ICAgIH0NCiAgICAgICAgICAgICBlbHNlDQogICAgICAgICAgICAgew0KICAgICAgICAgICAgICAg ICAvKiBXZWlnaHQtZHJpdmVuIGRvbWFpbnMgd2l0aCByZWFsLXRpbWUgZXhlY3V0aW9uLiAqLw0K LSAgICAgICAgICAgICAgICBmb3JfZWFjaF92Y3B1ICggcCwgdiApDQorICAgICAgICAgICAgICAg IGZvcl9lYWNoX3ZjcHUgKCBwLCB2ICkgew0KKyAgICAgICAgICAgICAgICAgICAgdmNwdV9zY2hl ZHVsZV9sb2NrKHYpOw0KICAgICAgICAgICAgICAgICAgICAgRURPTV9JTkZPKHYpLT53ZWlnaHQg PSBvcC0+dS5zZWRmLndlaWdodDsNCisgICAgICAgICAgICAgICAgICAgIHZjcHVfc2NoZWR1bGVf dW5sb2NrKHYpOw0KKyAgICAgICAgICAgICAgICB9DQogICAgICAgICAgICAgfQ0KICAgICAgICAg fQ0KICAgICAgICAgZWxzZQ0KICAgICAgICAgew0KKyAgICAgICAgICAgIC8qDQorICAgICAgICAg ICAgICogU2FuaXR5IGNoZWNraW5nOiBub3RlIHRoYXQgZGlzYWJsaW5nIGV4dHJhIHdlaWdodCBy ZXF1aXJlcw0KKyAgICAgICAgICAgICAqIHRoYXQgd2Ugc2V0IGEgbm9uLXplcm8gc2xpY2UuDQor ICAgICAgICAgICAgICovDQorICAgICAgICAgICAgaWYgKCAob3AtPnUuc2VkZi5wZXJpb2QgPiBQ RVJJT0RfTUFYKSB8fA0KKyAgICAgICAgICAgICAgICAgKG9wLT51LnNlZGYucGVyaW9kIDwgUEVS SU9EX01JTikgfHwNCisgICAgICAgICAgICAgICAgIChvcC0+dS5zZWRmLnNsaWNlICA+IG9wLT51 LnNlZGYucGVyaW9kKSB8fA0KKyAgICAgICAgICAgICAgICAgKG9wLT51LnNlZGYuc2xpY2UgIDwg U0xJQ0VfTUlOKSApDQorICAgICAgICAgICAgew0KKyAgICAgICAgICAgICAgICByYyA9IC1FSU5W QUw7DQorICAgICAgICAgICAgICAgIGdvdG8gb3V0Ow0KKyAgICAgICAgICAgIH0NCisNCiAgICAg ICAgICAgICAvKiBUaW1lLWRyaXZlbiBkb21haW5zLiAqLw0KICAgICAgICAgICAgIGZvcl9lYWNo X3ZjcHUgKCBwLCB2ICkNCiAgICAgICAgICAgICB7DQotICAgICAgICAgICAgICAgIC8qDQotICAg ICAgICAgICAgICAgICAqIFNhbml0eSBjaGVja2luZzogbm90ZSB0aGF0IGRpc2FibGluZyBleHRy YSB3ZWlnaHQgcmVxdWlyZXMNCi0gICAgICAgICAgICAgICAgICogdGhhdCB3ZSBzZXQgYSBub24t emVybyBzbGljZS4NCi0gICAgICAgICAgICAgICAgICovDQotICAgICAgICAgICAgICAgIGlmICgg KG9wLT51LnNlZGYucGVyaW9kID4gUEVSSU9EX01BWCkgfHwNCi0gICAgICAgICAgICAgICAgICAg ICAob3AtPnUuc2VkZi5wZXJpb2QgPCBQRVJJT0RfTUlOKSB8fA0KLSAgICAgICAgICAgICAgICAg ICAgIChvcC0+dS5zZWRmLnNsaWNlICA+IG9wLT51LnNlZGYucGVyaW9kKSB8fA0KLSAgICAgICAg ICAgICAgICAgICAgIChvcC0+dS5zZWRmLnNsaWNlICA8IFNMSUNFX01JTikgKQ0KLSAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIC1FSU5WQUw7DQorICAgICAgICAgICAgICAgIHZjcHVfc2NoZWR1 bGVfbG9jayh2KTsNCiAgICAgICAgICAgICAgICAgRURPTV9JTkZPKHYpLT53ZWlnaHQgPSAwOw0K ICAgICAgICAgICAgICAgICBFRE9NX0lORk8odiktPmV4dHJhd2VpZ2h0ID0gMDsNCiAgICAgICAg ICAgICAgICAgRURPTV9JTkZPKHYpLT5wZXJpb2Rfb3JpZyA9IA0KICAgICAgICAgICAgICAgICAg ICAgRURPTV9JTkZPKHYpLT5wZXJpb2QgID0gb3AtPnUuc2VkZi5wZXJpb2Q7DQogICAgICAgICAg ICAgICAgIEVET01fSU5GTyh2KS0+c2xpY2Vfb3JpZyAgPSANCiAgICAgICAgICAgICAgICAgICAg IEVET01fSU5GTyh2KS0+c2xpY2UgICA9IG9wLT51LnNlZGYuc2xpY2U7DQorICAgICAgICAgICAg ICAgIHZjcHVfc2NoZWR1bGVfdW5sb2NrKHYpOw0KICAgICAgICAgICAgIH0NCiAgICAgICAgIH0N CiANCi0gICAgICAgIHJjID0gc2VkZl9hZGp1c3Rfd2VpZ2h0cyhwLT5jcHVwb29sLCBvcCk7DQor ICAgICAgICByYyA9IHNlZGZfYWRqdXN0X3dlaWdodHMocC0+Y3B1cG9vbCwgbnJfY3B1cywgc3Vt dywgc3VtdCk7DQogICAgICAgICBpZiAoIHJjICkNCi0gICAgICAgICAgICByZXR1cm4gcmM7DQor ICAgICAgICAgICAgZ290byBvdXQ7DQogDQogICAgICAgICBmb3JfZWFjaF92Y3B1ICggcCwgdiAp DQogICAgICAgICB7DQorICAgICAgICAgICAgdmNwdV9zY2hlZHVsZV9sb2NrKHYpOw0KICAgICAg ICAgICAgIEVET01fSU5GTyh2KS0+c3RhdHVzICA9IA0KICAgICAgICAgICAgICAgICAoRURPTV9J TkZPKHYpLT5zdGF0dXMgJg0KICAgICAgICAgICAgICAgICAgfkVYVFJBX0FXQVJFKSB8IChvcC0+ dS5zZWRmLmV4dHJhdGltZSAmIEVYVFJBX0FXQVJFKTsNCiAgICAgICAgICAgICBFRE9NX0lORk8o diktPmxhdGVuY3kgPSBvcC0+dS5zZWRmLmxhdGVuY3k7DQogICAgICAgICAgICAgZXh0cmFxX2No ZWNrKHYpOw0KKyAgICAgICAgICAgIHZjcHVfc2NoZWR1bGVfdW5sb2NrKHYpOw0KICAgICAgICAg fQ0KICAgICB9DQogICAgIGVsc2UgaWYgKCBvcC0+Y21kID09IFhFTl9ET01DVExfU0NIRURPUF9n ZXRpbmZvICkNCiAgICAgew0KICAgICAgICAgaWYgKCBwLT52Y3B1WzBdID09IE5VTEwgKQ0KLSAg ICAgICAgICAgIHJldHVybiAtRUlOVkFMOw0KKyAgICAgICAgew0KKyAgICAgICAgICAgIHJjID0g LUVJTlZBTDsNCisgICAgICAgICAgICBnb3RvIG91dDsNCisgICAgICAgIH0NCisNCiAgICAgICAg IG9wLT51LnNlZGYucGVyaW9kICAgID0gRURPTV9JTkZPKHAtPnZjcHVbMF0pLT5wZXJpb2Q7DQog ICAgICAgICBvcC0+dS5zZWRmLnNsaWNlICAgICA9IEVET01fSU5GTyhwLT52Y3B1WzBdKS0+c2xp Y2U7DQogICAgICAgICBvcC0+dS5zZWRmLmV4dHJhdGltZSA9IEVET01fSU5GTyhwLT52Y3B1WzBd KS0+c3RhdHVzICYgRVhUUkFfQVdBUkU7DQpAQCAtMTQ3NywxNCArMTU0OSwyMyBAQCBzdGF0aWMg aW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlDQogICAgICAgICBvcC0+dS5zZWRmLndl aWdodCAgICA9IEVET01fSU5GTyhwLT52Y3B1WzBdKS0+d2VpZ2h0Ow0KICAgICB9DQogDQotICAg IFBSSU5UKDIsInNlZGZfYWRqdXN0X2ZpbmlzaGVkXG4iKTsNCi0gICAgcmV0dXJuIDA7DQorb3V0 Og0KKyAgICBzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcnYtPmxvY2ssIGZsYWdzKTsNCisNCisg ICAgeGZyZWUoc3VtdCk7DQorICAgIHhmcmVlKHN1bXcpOw0KKw0KKyAgICBQUklOVCgyLCJzZWRm X2FkanVzdF9maW5pc2hlZCB3aXRoIHJldHVybiBjb2RlICVkXG4iLCByYyk7DQorICAgIHJldHVy biByYzsNCiB9DQogDQorc3RhdGljIHN0cnVjdCBzZWRmX3ByaXZfaW5mbyBfc2VkZl9wcml2Ow0K Kw0KIGNvbnN0IHN0cnVjdCBzY2hlZHVsZXIgc2NoZWRfc2VkZl9kZWYgPSB7DQotICAgIC5uYW1l ICAgICA9ICJTaW1wbGUgRURGIFNjaGVkdWxlciIsDQotICAgIC5vcHRfbmFtZSA9ICJzZWRmIiwN Ci0gICAgLnNjaGVkX2lkID0gWEVOX1NDSEVEVUxFUl9TRURGLA0KKyAgICAubmFtZSAgICAgICAg ICAgPSAiU2ltcGxlIEVERiBTY2hlZHVsZXIiLA0KKyAgICAub3B0X25hbWUgICAgICAgPSAic2Vk ZiIsDQorICAgIC5zY2hlZF9pZCAgICAgICA9IFhFTl9TQ0hFRFVMRVJfU0VERiwNCisgICAgLnNj aGVkX2RhdGEgICAgID0gJl9zZWRmX3ByaXYsDQogICAgIA0KICAgICAuaW5pdF9kb21haW4gICAg PSBzZWRmX2luaXRfZG9tYWluLA0KICAgICAuZGVzdHJveV9kb21haW4gPSBzZWRmX2Rlc3Ryb3lf ZG9tYWluLA0KQEAgLTE0OTgsNiArMTU3OSw5IEBAIGNvbnN0IHN0cnVjdCBzY2hlZHVsZXIgc2No ZWRfc2VkZl9kZWYgPSANCiAgICAgLmFsbG9jX2RvbWRhdGEgID0gc2VkZl9hbGxvY19kb21kYXRh LA0KICAgICAuZnJlZV9kb21kYXRhICAgPSBzZWRmX2ZyZWVfZG9tZGF0YSwNCiANCisgICAgLmlu aXQgICAgICAgICAgID0gc2VkZl9pbml0LA0KKyAgICAuZGVpbml0ICAgICAgICAgPSBzZWRmX2Rl aW5pdCwNCisNCiAgICAgLmRvX3NjaGVkdWxlICAgID0gc2VkZl9kb19zY2hlZHVsZSwNCiAgICAg LnBpY2tfY3B1ICAgICAgID0gc2VkZl9waWNrX2NwdSwNCiAgICAgLmR1bXBfY3B1X3N0YXRlID0g c2VkZl9kdW1wX2NwdV9zdGF0ZSwNCmRpZmYgLXIgMTQ1MmZiMjQ4Y2Q1IHhlbi9jb21tb24vc2No ZWR1bGUuYw0KLS0tIGEveGVuL2NvbW1vbi9zY2hlZHVsZS5jCUZyaSBEZWMgMTYgMTU6NDU6NDAg MjAxMSArMDEwMA0KKysrIGIveGVuL2NvbW1vbi9zY2hlZHVsZS5jCUZyaSBEZWMgMTYgMTc6NDk6 NDYgMjAxMSArMDEwMA0KQEAgLTEwMDUsNyArMTAwNSw2IEBAIGludCBzY2hlZF9pZCh2b2lkKQ0K IC8qIEFkanVzdCBzY2hlZHVsaW5nIHBhcmFtZXRlciBmb3IgYSBnaXZlbiBkb21haW4uICovDQog bG9uZyBzY2hlZF9hZGp1c3Qoc3RydWN0IGRvbWFpbiAqZCwgc3RydWN0IHhlbl9kb21jdGxfc2No ZWR1bGVyX29wICpvcCkNCiB7DQotICAgIHN0cnVjdCB2Y3B1ICp2Ow0KICAgICBsb25nIHJldDsN CiAgICAgDQogICAgIGlmICggKG9wLT5zY2hlZF9pZCAhPSBET00yT1AoZCktPnNjaGVkX2lkKSB8 fA0KQEAgLTEwMTMsNDAgKzEwMTIsMTEgQEAgbG9uZyBzY2hlZF9hZGp1c3Qoc3RydWN0IGRvbWFp biAqZCwgc3RydQ0KICAgICAgICAgICAob3AtPmNtZCAhPSBYRU5fRE9NQ1RMX1NDSEVET1BfZ2V0 aW5mbykpICkNCiAgICAgICAgIHJldHVybiAtRUlOVkFMOw0KIA0KLSAgICAvKg0KLSAgICAgKiBN b3N0IFZDUFVzIHdlIGNhbiBzaW1wbHkgcGF1c2UuIElmIHdlIGFyZSBhZGp1c3RpbmcgdGhpcyBW Q1BVIHRoZW4NCi0gICAgICogd2UgYWNxdWlyZSB0aGUgbG9jYWwgc2NoZWR1bGVfbG9jayB0byBn dWFyZCBhZ2FpbnN0IGNvbmN1cnJlbnQgdXBkYXRlcy4NCi0gICAgICoNCi0gICAgICogV2Ugb25s eSBhY3F1aXJlIHRoZSBsb2NhbCBzY2hlZHVsZSBsb2NrIGFmdGVyIHdlIGhhdmUgcGF1c2VkIGFs bCBvdGhlcg0KLSAgICAgKiBWQ1BVcyBpbiB0aGlzIGRvbWFpbi4gVGhlcmUgYXJlIHR3byByZWFz b25zIGZvciB0aGlzOg0KLSAgICAgKiAxLSBXZSBkb24ndCB3YW50IHRvIGhvbGQgdXAgaW50ZXJy dXB0cyBhcyBwYXVzaW5nIGEgVkNQVSBjYW4NCi0gICAgICogICAgdHJpZ2dlciBhIHRsYiBzaG9v dGRvd24uDQotICAgICAqIDItIFBhdXNpbmcgb3RoZXIgVkNQVXMgaW52b2x2ZXMgYnJpZWZseSBs b2NraW5nIHRoZSBzY2hlZHVsZQ0KLSAgICAgKiAgICBsb2NrIG9mIHRoZSBDUFUgdGhleSBhcmUg cnVubmluZyBvbi4gVGhpcyBDUFUgY291bGQgYmUgdGhlDQotICAgICAqICAgIHNhbWUgYXMgb3Vy cy4NCi0gICAgICovDQotDQotICAgIGZvcl9lYWNoX3ZjcHUgKCBkLCB2ICkNCi0gICAgew0KLSAg ICAgICAgaWYgKCB2ICE9IGN1cnJlbnQgKQ0KLSAgICAgICAgICAgIHZjcHVfcGF1c2Uodik7DQot ICAgIH0NCi0NCi0gICAgaWYgKCBkID09IGN1cnJlbnQtPmRvbWFpbiApDQotICAgICAgICB2Y3B1 X3NjaGVkdWxlX2xvY2tfaXJxKGN1cnJlbnQpOw0KLQ0KKyAgICAvKiBOQjogdGhlIHBsdWdnYWJs ZSBzY2hlZHVsZXIgY29kZSBuZWVkcyB0byB0YWtlIGNhcmUNCisgICAgICogb2YgbG9ja2luZyBi eSBpdHNlbGYuICovDQogICAgIGlmICggKHJldCA9IFNDSEVEX09QKERPTTJPUChkKSwgYWRqdXN0 LCBkLCBvcCkpID09IDAgKQ0KICAgICAgICAgVFJBQ0VfMUQoVFJDX1NDSEVEX0FESkRPTSwgZC0+ ZG9tYWluX2lkKTsNCiANCi0gICAgaWYgKCBkID09IGN1cnJlbnQtPmRvbWFpbiApDQotICAgICAg ICB2Y3B1X3NjaGVkdWxlX3VubG9ja19pcnEoY3VycmVudCk7DQotDQotICAgIGZvcl9lYWNoX3Zj cHUgKCBkLCB2ICkNCi0gICAgew0KLSAgICAgICAgaWYgKCB2ICE9IGN1cnJlbnQgKQ0KLSAgICAg ICAgICAgIHZjcHVfdW5wYXVzZSh2KTsNCi0gICAgfQ0KLQ0KICAgICByZXR1cm4gcmV0Ow0KIH0N CiANCg== --=-2gDoRwjHAIAVny3ceOG+-- --=-s6aQxhtWfeniZORipy49 Content-Type: application/pgp-signature; name="signature.asc" Content-Description: This is a digitally signed message part Content-Transfer-Encoding: 7bit -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.11 (GNU/Linux) iEYEABECAAYFAk7rd5gACgkQk4XaBE3IOsRF4ACeJ7pXxiy0P4aZa825gcDm0HXx v4cAoJH8+VULHbpCzzh5USbGN7Xwzupv =FzAW -----END PGP SIGNATURE----- --=-s6aQxhtWfeniZORipy49-- --===============0469156300206918351== 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.xensource.com http://lists.xensource.com/xen-devel --===============0469156300206918351==--