From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dario Faggioli Subject: [PATCH 1 of 1] sched: rework locking for dump debugkey. Date: Wed, 18 Jan 2012 17:24:54 +0100 Message-ID: <1326903894.5856.35.camel@Solace> References: <1326903221.5856.33.camel@Solace> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="===============6363075103574912662==" Return-path: In-Reply-To: <1326903221.5856.33.camel@Solace> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xensource.com Errors-To: xen-devel-bounces@lists.xensource.com To: George Dunlap Cc: "xen-devel@lists.xensource.com" , "Keir (Xen.org)" List-Id: xen-devel@lists.xenproject.org --===============6363075103574912662== Content-Type: multipart/signed; micalg="pgp-sha1"; protocol="application/pgp-signature"; boundary="=-ApW/FEYJ2HeKXZmm9mdH" --=-ApW/FEYJ2HeKXZmm9mdH Content-Type: multipart/mixed; boundary="=-Sn+NDJR3EWzB5LTDsO7k" --=-Sn+NDJR3EWzB5LTDsO7k Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable As in all other paths, locking should be dealt with in the specific schedulers, not in schedule.c. Signed-off-by: Dario Faggioli diff -r 15ab61865ecb xen/common/sched_credit.c --- a/xen/common/sched_credit.c Tue Jan 17 12:40:52 2012 +0000 +++ b/xen/common/sched_credit.c Wed Jan 18 15:02:30 2012 +0000 @@ -1451,11 +1451,16 @@ static void csched_dump_pcpu(const struct scheduler *ops, int cpu) { struct list_head *runq, *iter; + struct csched_private *prv =3D CSCHED_PRIV(ops); struct csched_pcpu *spc; struct csched_vcpu *svc; + unsigned long flags; int loop; #define cpustr keyhandler_scratch =20 + /* Domains' parameters are changed under csched_priv lock */ + spin_lock_irqsave(&prv->lock, flags); + spc =3D CSCHED_PCPU(cpu); runq =3D &spc->runq; =20 @@ -1464,6 +1469,12 @@ csched_dump_pcpu(const struct scheduler=20 cpumask_scnprintf(cpustr, sizeof(cpustr), per_cpu(cpu_core_mask, cpu))= ; printk("core=3D%s\n", cpustr); =20 + /* + * We need runq lock as well, and as there's one runq per CPU, + * this is the correct one to take for this CPU/runq. + */ + pcpu_schedule_lock(cpu); + /* current VCPU */ svc =3D CSCHED_VCPU(per_cpu(schedule_data, cpu).curr); if ( svc ) @@ -1482,6 +1493,9 @@ csched_dump_pcpu(const struct scheduler=20 csched_dump_vcpu(svc); } } + + pcpu_schedule_unlock(cpu); + spin_unlock_irqrestore(&prv->lock, flags); #undef cpustr } =20 @@ -1493,7 +1507,7 @@ csched_dump(const struct scheduler *ops) int loop; unsigned long flags; =20 - spin_lock_irqsave(&(prv->lock), flags); + spin_lock_irqsave(&prv->lock, flags); =20 #define idlers_buf keyhandler_scratch =20 @@ -1537,12 +1551,14 @@ csched_dump(const struct scheduler *ops) svc =3D list_entry(iter_svc, struct csched_vcpu, active_vcpu_e= lem); =20 printk("\t%3d: ", ++loop); + vcpu_schedule_lock(svc->vcpu); csched_dump_vcpu(svc); + vcpu_schedule_unlock(svc->vcpu); } } #undef idlers_buf =20 - spin_unlock_irqrestore(&(prv->lock), flags); + spin_unlock_irqrestore(&prv->lock, flags); } =20 static int diff -r 15ab61865ecb xen/common/sched_credit2.c --- a/xen/common/sched_credit2.c Tue Jan 17 12:40:52 2012 +0000 +++ b/xen/common/sched_credit2.c Wed Jan 18 15:02:30 2012 +0000 @@ -53,8 +53,6 @@ * credit2 wiki page: * http://wiki.xen.org/wiki/Credit2_Scheduler_Development * TODO: - * + Immediate bug-fixes - * - Do per-runqueue, grab proper lock for dump debugkey * + Multiple sockets * - Detect cpu layout and make runqueue map, one per L2 (make_runq_map()= ) * - Simple load balancer / runqueue assignment @@ -1759,12 +1757,16 @@ csched_dump_vcpu(struct csched_vcpu *svc static void csched_dump_pcpu(const struct scheduler *ops, int cpu) { + struct csched_private *prv =3D CSCHED_PRIV(ops); struct list_head *runq, *iter; struct csched_vcpu *svc; + unsigned long flags; + spinlock_t *lock; int loop; char cpustr[100]; =20 - /* FIXME: Do locking properly for access to runqueue structures */ + /* Domains' parameters are changed under csched_priv lock */ + spin_lock_irqsave(&prv->lock, flags); =20 runq =3D &RQD(ops, cpu)->runq; =20 @@ -1773,6 +1775,13 @@ csched_dump_pcpu(const struct scheduler=20 cpumask_scnprintf(cpustr, sizeof(cpustr), per_cpu(cpu_core_mask, cpu))= ; printk("core=3D%s\n", cpustr); =20 + /* + * We need runq lock as well, and here's how we get to it + * for the requested cpu. + */ + lock =3D per_cpu(schedule_data, cpu).schedule_lock; + spin_lock(lock); + /* current VCPU */ svc =3D CSCHED_VCPU(per_cpu(schedule_data, cpu).curr); if ( svc ) @@ -1791,6 +1800,9 @@ csched_dump_pcpu(const struct scheduler=20 csched_dump_vcpu(svc); } } + + spin_unlock(lock); + spin_unlock_irqrestore(&prv->lock, flags); } =20 static void @@ -1798,8 +1810,11 @@ csched_dump(const struct scheduler *ops) { struct list_head *iter_sdom, *iter_svc; struct csched_private *prv =3D CSCHED_PRIV(ops); + unsigned long flags; int i, loop; =20 + spin_lock_irqsave(&prv->lock, flags); + printk("Active queues: %d\n" "\tdefault-weight =3D %d\n", cpumask_weight(&prv->active_queues), @@ -1822,7 +1837,6 @@ csched_dump(const struct scheduler *ops) fraction); =20 } - /* FIXME: Locking! */ =20 printk("Domain info:\n"); loop =3D 0; @@ -1831,10 +1845,10 @@ csched_dump(const struct scheduler *ops) struct csched_dom *sdom; sdom =3D list_entry(iter_sdom, struct csched_dom, sdom_elem); =20 - printk("\tDomain: %d w %d v %d\n\t",=20 - sdom->dom->domain_id,=20 - sdom->weight,=20 - sdom->nr_vcpus); + printk("\tDomain: %d w %d v %d\n\t",=20 + sdom->dom->domain_id,=20 + sdom->weight,=20 + sdom->nr_vcpus); =20 list_for_each( iter_svc, &sdom->vcpu ) { @@ -1842,9 +1856,13 @@ csched_dump(const struct scheduler *ops) svc =3D list_entry(iter_svc, struct csched_vcpu, sdom_elem); =20 printk("\t%3d: ", ++loop); + vcpu_schedule_lock(svc->vcpu); csched_dump_vcpu(svc); + vcpu_schedule_unlock(svc->vcpu); } } + + spin_unlock_irqrestore(&prv->lock, flags); } =20 static void activate_runqueue(struct csched_private *prv, int rqi) diff -r 15ab61865ecb xen/common/sched_sedf.c --- a/xen/common/sched_sedf.c Tue Jan 17 12:40:52 2012 +0000 +++ b/xen/common/sched_sedf.c Wed Jan 18 15:02:30 2012 +0000 @@ -1219,13 +1219,25 @@ static void sedf_dump_domain(struct vcpu /* Dumps all domains on the specified cpu */ static void sedf_dump_cpu_state(const struct scheduler *ops, int i) { + struct sedf_priv_info *prv =3D SEDF_PRIV(ops); struct list_head *list, *queue, *tmp; struct sedf_vcpu_info *d_inf; struct domain *d; struct vcpu *ed; + unsigned long flags; int loop =3D 0; + + /* Domains' parameters are changed under scheduler lock */ + spin_lock_irqsave(&prv->lock, flags); =20 printk("now=3D%"PRIu64"\n",NOW()); + + /* + * We need runq lock as well, and as there's one runq per CPU, + * this is the correct one to take for this CPU/runq. + */ + pcpu_schedule_lock(i); + queue =3D RUNQ(i); printk("RUNQ rq %lx n: %lx, p: %lx\n", (unsigned long)queue, (unsigned long) queue->next, (unsigned long) queue->prev); @@ -1288,6 +1300,9 @@ static void sedf_dump_cpu_state(const st } } rcu_read_unlock(&domlist_read_lock); + + pcpu_schedule_unlock(i); + spin_unlock_irqrestore(&prv->lock, flags); } =20 =20 diff -r 15ab61865ecb xen/common/schedule.c --- a/xen/common/schedule.c Tue Jan 17 12:40:52 2012 +0000 +++ b/xen/common/schedule.c Wed Jan 18 15:02:30 2012 +0000 @@ -1417,6 +1417,7 @@ void schedule_dump(struct cpupool *c) struct scheduler *sched; cpumask_t *cpus; =20 + /* Proper locking is provided by each scheduler */ sched =3D (c =3D=3D NULL) ? &ops : c->sched; cpus =3D (c =3D=3D NULL) ? &cpupool_free_cpus : c->cpu_valid; printk("Scheduler: %s (%s)\n", sched->name, sched->opt_name); @@ -1424,10 +1425,8 @@ void schedule_dump(struct cpupool *c) =20 for_each_cpu (i, cpus) { - pcpu_schedule_lock(i); printk("CPU[%02d] ", i); SCHED_OP(sched, dump_cpu_state, i); - pcpu_schedule_unlock(i); } } =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) --=-Sn+NDJR3EWzB5LTDsO7k Content-Disposition: attachment; filename="rework-locking-for-dump-status.patch" Content-Type: text/x-patch; name="rework-locking-for-dump-status.patch"; charset="UTF-8" Content-Transfer-Encoding: base64 IyBIRyBjaGFuZ2VzZXQgcGF0Y2gNCiMgUGFyZW50IDE1YWI2MTg2NWVjYmQxNDZmNmNlNjVmYmVh NWJmNDliZmQ5YzZjYjENCnNjaGVkOiByZXdvcmsgbG9ja2luZyBmb3IgZHVtcCBkZWJ1Z2tleS4N Cg0KQXMgaW4gYWxsIG90aGVyIHBhdGhzLCBsb2NraW5nIHNob3VsZCBiZSBkZWFsdCB3aXRoIGlu IHRoZQ0Kc3BlY2lmaWMgc2NoZWR1bGVycywgbm90IGluIHNjaGVkdWxlLmMuDQoNClNpZ25lZC1v ZmYtYnk6IERhcmlvIEZhZ2dpb2xpIDxkYXJpby5mYWdnaW9saUBjaXRyaXguY29tPg0KDQpkaWZm IC1yIDE1YWI2MTg2NWVjYiB4ZW4vY29tbW9uL3NjaGVkX2NyZWRpdC5jDQotLS0gYS94ZW4vY29t bW9uL3NjaGVkX2NyZWRpdC5jCVR1ZSBKYW4gMTcgMTI6NDA6NTIgMjAxMiArMDAwMA0KKysrIGIv eGVuL2NvbW1vbi9zY2hlZF9jcmVkaXQuYwlXZWQgSmFuIDE4IDE1OjAyOjMwIDIwMTIgKzAwMDAN CkBAIC0xNDUxLDExICsxNDUxLDE2IEBAIHN0YXRpYyB2b2lkDQogY3NjaGVkX2R1bXBfcGNwdShj b25zdCBzdHJ1Y3Qgc2NoZWR1bGVyICpvcHMsIGludCBjcHUpDQogew0KICAgICBzdHJ1Y3QgbGlz dF9oZWFkICpydW5xLCAqaXRlcjsNCisgICAgc3RydWN0IGNzY2hlZF9wcml2YXRlICpwcnYgPSBD U0NIRURfUFJJVihvcHMpOw0KICAgICBzdHJ1Y3QgY3NjaGVkX3BjcHUgKnNwYzsNCiAgICAgc3Ry dWN0IGNzY2hlZF92Y3B1ICpzdmM7DQorICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7DQogICAgIGlu dCBsb29wOw0KICNkZWZpbmUgY3B1c3RyIGtleWhhbmRsZXJfc2NyYXRjaA0KIA0KKyAgICAvKiBE b21haW5zJyBwYXJhbWV0ZXJzIGFyZSBjaGFuZ2VkIHVuZGVyIGNzY2hlZF9wcml2IGxvY2sgKi8N CisgICAgc3Bpbl9sb2NrX2lycXNhdmUoJnBydi0+bG9jaywgZmxhZ3MpOw0KKw0KICAgICBzcGMg PSBDU0NIRURfUENQVShjcHUpOw0KICAgICBydW5xID0gJnNwYy0+cnVucTsNCiANCkBAIC0xNDY0 LDYgKzE0NjksMTIgQEAgY3NjaGVkX2R1bXBfcGNwdShjb25zdCBzdHJ1Y3Qgc2NoZWR1bGVyIA0K ICAgICBjcHVtYXNrX3NjbnByaW50ZihjcHVzdHIsIHNpemVvZihjcHVzdHIpLCBwZXJfY3B1KGNw dV9jb3JlX21hc2ssIGNwdSkpOw0KICAgICBwcmludGsoImNvcmU9JXNcbiIsIGNwdXN0cik7DQog DQorICAgIC8qDQorICAgICAqIFdlIG5lZWQgcnVucSBsb2NrIGFzIHdlbGwsIGFuZCBhcyB0aGVy ZSdzIG9uZSBydW5xIHBlciBDUFUsDQorICAgICAqIHRoaXMgaXMgdGhlIGNvcnJlY3Qgb25lIHRv IHRha2UgZm9yIHRoaXMgQ1BVL3J1bnEuDQorICAgICAqLw0KKyAgICBwY3B1X3NjaGVkdWxlX2xv Y2soY3B1KTsNCisNCiAgICAgLyogY3VycmVudCBWQ1BVICovDQogICAgIHN2YyA9IENTQ0hFRF9W Q1BVKHBlcl9jcHUoc2NoZWR1bGVfZGF0YSwgY3B1KS5jdXJyKTsNCiAgICAgaWYgKCBzdmMgKQ0K QEAgLTE0ODIsNiArMTQ5Myw5IEBAIGNzY2hlZF9kdW1wX3BjcHUoY29uc3Qgc3RydWN0IHNjaGVk dWxlciANCiAgICAgICAgICAgICBjc2NoZWRfZHVtcF92Y3B1KHN2Yyk7DQogICAgICAgICB9DQog ICAgIH0NCisNCisgICAgcGNwdV9zY2hlZHVsZV91bmxvY2soY3B1KTsNCisgICAgc3Bpbl91bmxv Y2tfaXJxcmVzdG9yZSgmcHJ2LT5sb2NrLCBmbGFncyk7DQogI3VuZGVmIGNwdXN0cg0KIH0NCiAN CkBAIC0xNDkzLDcgKzE1MDcsNyBAQCBjc2NoZWRfZHVtcChjb25zdCBzdHJ1Y3Qgc2NoZWR1bGVy ICpvcHMpDQogICAgIGludCBsb29wOw0KICAgICB1bnNpZ25lZCBsb25nIGZsYWdzOw0KIA0KLSAg ICBzcGluX2xvY2tfaXJxc2F2ZSgmKHBydi0+bG9jayksIGZsYWdzKTsNCisgICAgc3Bpbl9sb2Nr X2lycXNhdmUoJnBydi0+bG9jaywgZmxhZ3MpOw0KIA0KICNkZWZpbmUgaWRsZXJzX2J1ZiBrZXlo YW5kbGVyX3NjcmF0Y2gNCiANCkBAIC0xNTM3LDEyICsxNTUxLDE0IEBAIGNzY2hlZF9kdW1wKGNv bnN0IHN0cnVjdCBzY2hlZHVsZXIgKm9wcykNCiAgICAgICAgICAgICBzdmMgPSBsaXN0X2VudHJ5 KGl0ZXJfc3ZjLCBzdHJ1Y3QgY3NjaGVkX3ZjcHUsIGFjdGl2ZV92Y3B1X2VsZW0pOw0KIA0KICAg ICAgICAgICAgIHByaW50aygiXHQlM2Q6ICIsICsrbG9vcCk7DQorICAgICAgICAgICAgdmNwdV9z Y2hlZHVsZV9sb2NrKHN2Yy0+dmNwdSk7DQogICAgICAgICAgICAgY3NjaGVkX2R1bXBfdmNwdShz dmMpOw0KKyAgICAgICAgICAgIHZjcHVfc2NoZWR1bGVfdW5sb2NrKHN2Yy0+dmNwdSk7DQogICAg ICAgICB9DQogICAgIH0NCiAjdW5kZWYgaWRsZXJzX2J1Zg0KIA0KLSAgICBzcGluX3VubG9ja19p cnFyZXN0b3JlKCYocHJ2LT5sb2NrKSwgZmxhZ3MpOw0KKyAgICBzcGluX3VubG9ja19pcnFyZXN0 b3JlKCZwcnYtPmxvY2ssIGZsYWdzKTsNCiB9DQogDQogc3RhdGljIGludA0KZGlmZiAtciAxNWFi NjE4NjVlY2IgeGVuL2NvbW1vbi9zY2hlZF9jcmVkaXQyLmMNCi0tLSBhL3hlbi9jb21tb24vc2No ZWRfY3JlZGl0Mi5jCVR1ZSBKYW4gMTcgMTI6NDA6NTIgMjAxMiArMDAwMA0KKysrIGIveGVuL2Nv bW1vbi9zY2hlZF9jcmVkaXQyLmMJV2VkIEphbiAxOCAxNTowMjozMCAyMDEyICswMDAwDQpAQCAt NTMsOCArNTMsNiBAQA0KICAqIGNyZWRpdDIgd2lraSBwYWdlOg0KICAqICBodHRwOi8vd2lraS54 ZW4ub3JnL3dpa2kvQ3JlZGl0Ml9TY2hlZHVsZXJfRGV2ZWxvcG1lbnQNCiAgKiBUT0RPOg0KLSAq ICsgSW1tZWRpYXRlIGJ1Zy1maXhlcw0KLSAqICAtIERvIHBlci1ydW5xdWV1ZSwgZ3JhYiBwcm9w ZXIgbG9jayBmb3IgZHVtcCBkZWJ1Z2tleQ0KICAqICsgTXVsdGlwbGUgc29ja2V0cw0KICAqICAt IERldGVjdCBjcHUgbGF5b3V0IGFuZCBtYWtlIHJ1bnF1ZXVlIG1hcCwgb25lIHBlciBMMiAobWFr ZV9ydW5xX21hcCgpKQ0KICAqICAtIFNpbXBsZSBsb2FkIGJhbGFuY2VyIC8gcnVucXVldWUgYXNz aWdubWVudA0KQEAgLTE3NTksMTIgKzE3NTcsMTYgQEAgY3NjaGVkX2R1bXBfdmNwdShzdHJ1Y3Qg Y3NjaGVkX3ZjcHUgKnN2Yw0KIHN0YXRpYyB2b2lkDQogY3NjaGVkX2R1bXBfcGNwdShjb25zdCBz dHJ1Y3Qgc2NoZWR1bGVyICpvcHMsIGludCBjcHUpDQogew0KKyAgICBzdHJ1Y3QgY3NjaGVkX3By aXZhdGUgKnBydiA9IENTQ0hFRF9QUklWKG9wcyk7DQogICAgIHN0cnVjdCBsaXN0X2hlYWQgKnJ1 bnEsICppdGVyOw0KICAgICBzdHJ1Y3QgY3NjaGVkX3ZjcHUgKnN2YzsNCisgICAgdW5zaWduZWQg bG9uZyBmbGFnczsNCisgICAgc3BpbmxvY2tfdCAqbG9jazsNCiAgICAgaW50IGxvb3A7DQogICAg IGNoYXIgY3B1c3RyWzEwMF07DQogDQotICAgIC8qIEZJWE1FOiBEbyBsb2NraW5nIHByb3Blcmx5 IGZvciBhY2Nlc3MgdG8gcnVucXVldWUgc3RydWN0dXJlcyAqLw0KKyAgICAvKiBEb21haW5zJyBw YXJhbWV0ZXJzIGFyZSBjaGFuZ2VkIHVuZGVyIGNzY2hlZF9wcml2IGxvY2sgKi8NCisgICAgc3Bp bl9sb2NrX2lycXNhdmUoJnBydi0+bG9jaywgZmxhZ3MpOw0KIA0KICAgICBydW5xID0gJlJRRChv cHMsIGNwdSktPnJ1bnE7DQogDQpAQCAtMTc3Myw2ICsxNzc1LDEzIEBAIGNzY2hlZF9kdW1wX3Bj cHUoY29uc3Qgc3RydWN0IHNjaGVkdWxlciANCiAgICAgY3B1bWFza19zY25wcmludGYoY3B1c3Ry LCBzaXplb2YoY3B1c3RyKSwgcGVyX2NwdShjcHVfY29yZV9tYXNrLCBjcHUpKTsNCiAgICAgcHJp bnRrKCJjb3JlPSVzXG4iLCBjcHVzdHIpOw0KIA0KKyAgICAvKg0KKyAgICAgKiBXZSBuZWVkIHJ1 bnEgbG9jayBhcyB3ZWxsLCBhbmQgaGVyZSdzIGhvdyB3ZSBnZXQgdG8gaXQNCisgICAgICogZm9y IHRoZSByZXF1ZXN0ZWQgY3B1Lg0KKyAgICAgKi8NCisgICAgbG9jayA9IHBlcl9jcHUoc2NoZWR1 bGVfZGF0YSwgY3B1KS5zY2hlZHVsZV9sb2NrOw0KKyAgICBzcGluX2xvY2sobG9jayk7DQorDQog ICAgIC8qIGN1cnJlbnQgVkNQVSAqLw0KICAgICBzdmMgPSBDU0NIRURfVkNQVShwZXJfY3B1KHNj aGVkdWxlX2RhdGEsIGNwdSkuY3Vycik7DQogICAgIGlmICggc3ZjICkNCkBAIC0xNzkxLDYgKzE4 MDAsOSBAQCBjc2NoZWRfZHVtcF9wY3B1KGNvbnN0IHN0cnVjdCBzY2hlZHVsZXIgDQogICAgICAg ICAgICAgY3NjaGVkX2R1bXBfdmNwdShzdmMpOw0KICAgICAgICAgfQ0KICAgICB9DQorDQorICAg IHNwaW5fdW5sb2NrKGxvY2spOw0KKyAgICBzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcnYtPmxv Y2ssIGZsYWdzKTsNCiB9DQogDQogc3RhdGljIHZvaWQNCkBAIC0xNzk4LDggKzE4MTAsMTEgQEAg Y3NjaGVkX2R1bXAoY29uc3Qgc3RydWN0IHNjaGVkdWxlciAqb3BzKQ0KIHsNCiAgICAgc3RydWN0 IGxpc3RfaGVhZCAqaXRlcl9zZG9tLCAqaXRlcl9zdmM7DQogICAgIHN0cnVjdCBjc2NoZWRfcHJp dmF0ZSAqcHJ2ID0gQ1NDSEVEX1BSSVYob3BzKTsNCisgICAgdW5zaWduZWQgbG9uZyBmbGFnczsN CiAgICAgaW50IGksIGxvb3A7DQogDQorICAgIHNwaW5fbG9ja19pcnFzYXZlKCZwcnYtPmxvY2ss IGZsYWdzKTsNCisNCiAgICAgcHJpbnRrKCJBY3RpdmUgcXVldWVzOiAlZFxuIg0KICAgICAgICAg ICAgIlx0ZGVmYXVsdC13ZWlnaHQgICAgID0gJWRcbiIsDQogICAgICAgICAgICBjcHVtYXNrX3dl aWdodCgmcHJ2LT5hY3RpdmVfcXVldWVzKSwNCkBAIC0xODIyLDcgKzE4MzcsNiBAQCBjc2NoZWRf ZHVtcChjb25zdCBzdHJ1Y3Qgc2NoZWR1bGVyICpvcHMpDQogICAgICAgICAgICAgICAgZnJhY3Rp b24pOw0KIA0KICAgICB9DQotICAgIC8qIEZJWE1FOiBMb2NraW5nISAqLw0KIA0KICAgICBwcmlu dGsoIkRvbWFpbiBpbmZvOlxuIik7DQogICAgIGxvb3AgPSAwOw0KQEAgLTE4MzEsMTAgKzE4NDUs MTAgQEAgY3NjaGVkX2R1bXAoY29uc3Qgc3RydWN0IHNjaGVkdWxlciAqb3BzKQ0KICAgICAgICAg c3RydWN0IGNzY2hlZF9kb20gKnNkb207DQogICAgICAgICBzZG9tID0gbGlzdF9lbnRyeShpdGVy X3Nkb20sIHN0cnVjdCBjc2NoZWRfZG9tLCBzZG9tX2VsZW0pOw0KIA0KLSAgICAgICBwcmludGso Ilx0RG9tYWluOiAlZCB3ICVkIHYgJWRcblx0IiwgDQotICAgICAgICAgICAgICBzZG9tLT5kb20t PmRvbWFpbl9pZCwgDQotICAgICAgICAgICAgICBzZG9tLT53ZWlnaHQsIA0KLSAgICAgICAgICAg ICAgc2RvbS0+bnJfdmNwdXMpOw0KKyAgICAgICAgcHJpbnRrKCJcdERvbWFpbjogJWQgdyAlZCB2 ICVkXG5cdCIsIA0KKyAgICAgICAgICAgICAgIHNkb20tPmRvbS0+ZG9tYWluX2lkLCANCisgICAg ICAgICAgICAgICBzZG9tLT53ZWlnaHQsIA0KKyAgICAgICAgICAgICAgIHNkb20tPm5yX3ZjcHVz KTsNCiANCiAgICAgICAgIGxpc3RfZm9yX2VhY2goIGl0ZXJfc3ZjLCAmc2RvbS0+dmNwdSApDQog ICAgICAgICB7DQpAQCAtMTg0Miw5ICsxODU2LDEzIEBAIGNzY2hlZF9kdW1wKGNvbnN0IHN0cnVj dCBzY2hlZHVsZXIgKm9wcykNCiAgICAgICAgICAgICBzdmMgPSBsaXN0X2VudHJ5KGl0ZXJfc3Zj LCBzdHJ1Y3QgY3NjaGVkX3ZjcHUsIHNkb21fZWxlbSk7DQogDQogICAgICAgICAgICAgcHJpbnRr KCJcdCUzZDogIiwgKytsb29wKTsNCisgICAgICAgICAgICB2Y3B1X3NjaGVkdWxlX2xvY2soc3Zj LT52Y3B1KTsNCiAgICAgICAgICAgICBjc2NoZWRfZHVtcF92Y3B1KHN2Yyk7DQorICAgICAgICAg ICAgdmNwdV9zY2hlZHVsZV91bmxvY2soc3ZjLT52Y3B1KTsNCiAgICAgICAgIH0NCiAgICAgfQ0K Kw0KKyAgICBzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcnYtPmxvY2ssIGZsYWdzKTsNCiB9DQog DQogc3RhdGljIHZvaWQgYWN0aXZhdGVfcnVucXVldWUoc3RydWN0IGNzY2hlZF9wcml2YXRlICpw cnYsIGludCBycWkpDQpkaWZmIC1yIDE1YWI2MTg2NWVjYiB4ZW4vY29tbW9uL3NjaGVkX3NlZGYu Yw0KLS0tIGEveGVuL2NvbW1vbi9zY2hlZF9zZWRmLmMJVHVlIEphbiAxNyAxMjo0MDo1MiAyMDEy ICswMDAwDQorKysgYi94ZW4vY29tbW9uL3NjaGVkX3NlZGYuYwlXZWQgSmFuIDE4IDE1OjAyOjMw IDIwMTIgKzAwMDANCkBAIC0xMjE5LDEzICsxMjE5LDI1IEBAIHN0YXRpYyB2b2lkIHNlZGZfZHVt cF9kb21haW4oc3RydWN0IHZjcHUNCiAvKiBEdW1wcyBhbGwgZG9tYWlucyBvbiB0aGUgc3BlY2lm aWVkIGNwdSAqLw0KIHN0YXRpYyB2b2lkIHNlZGZfZHVtcF9jcHVfc3RhdGUoY29uc3Qgc3RydWN0 IHNjaGVkdWxlciAqb3BzLCBpbnQgaSkNCiB7DQorICAgIHN0cnVjdCBzZWRmX3ByaXZfaW5mbyAq cHJ2ID0gU0VERl9QUklWKG9wcyk7DQogICAgIHN0cnVjdCBsaXN0X2hlYWQgICAgICAqbGlzdCwg KnF1ZXVlLCAqdG1wOw0KICAgICBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8gKmRfaW5mOw0KICAgICBz dHJ1Y3QgZG9tYWluICAgICAgICAgKmQ7DQogICAgIHN0cnVjdCB2Y3B1ICAgICplZDsNCisgICAg dW5zaWduZWQgbG9uZyBmbGFnczsNCiAgICAgaW50IGxvb3AgPSAwOw0KKw0KKyAgICAvKiBEb21h aW5zJyBwYXJhbWV0ZXJzIGFyZSBjaGFuZ2VkIHVuZGVyIHNjaGVkdWxlciBsb2NrICovDQorICAg IHNwaW5fbG9ja19pcnFzYXZlKCZwcnYtPmxvY2ssIGZsYWdzKTsNCiAgDQogICAgIHByaW50aygi bm93PSUiUFJJdTY0IlxuIixOT1coKSk7DQorDQorICAgIC8qDQorICAgICAqIFdlIG5lZWQgcnVu cSBsb2NrIGFzIHdlbGwsIGFuZCBhcyB0aGVyZSdzIG9uZSBydW5xIHBlciBDUFUsDQorICAgICAq IHRoaXMgaXMgdGhlIGNvcnJlY3Qgb25lIHRvIHRha2UgZm9yIHRoaXMgQ1BVL3J1bnEuDQorICAg ICAqLw0KKyAgICBwY3B1X3NjaGVkdWxlX2xvY2soaSk7DQorDQogICAgIHF1ZXVlID0gUlVOUShp KTsNCiAgICAgcHJpbnRrKCJSVU5RIHJxICVseCAgIG46ICVseCwgcDogJWx4XG4iLCAgKHVuc2ln bmVkIGxvbmcpcXVldWUsDQogICAgICAgICAgICAodW5zaWduZWQgbG9uZykgcXVldWUtPm5leHQs ICh1bnNpZ25lZCBsb25nKSBxdWV1ZS0+cHJldik7DQpAQCAtMTI4OCw2ICsxMzAwLDkgQEAgc3Rh dGljIHZvaWQgc2VkZl9kdW1wX2NwdV9zdGF0ZShjb25zdCBzdA0KICAgICAgICAgfQ0KICAgICB9 DQogICAgIHJjdV9yZWFkX3VubG9jaygmZG9tbGlzdF9yZWFkX2xvY2spOw0KKw0KKyAgICBwY3B1 X3NjaGVkdWxlX3VubG9jayhpKTsNCisgICAgc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJ2LT5s b2NrLCBmbGFncyk7DQogfQ0KIA0KIA0KZGlmZiAtciAxNWFiNjE4NjVlY2IgeGVuL2NvbW1vbi9z Y2hlZHVsZS5jDQotLS0gYS94ZW4vY29tbW9uL3NjaGVkdWxlLmMJVHVlIEphbiAxNyAxMjo0MDo1 MiAyMDEyICswMDAwDQorKysgYi94ZW4vY29tbW9uL3NjaGVkdWxlLmMJV2VkIEphbiAxOCAxNTow MjozMCAyMDEyICswMDAwDQpAQCAtMTQxNyw2ICsxNDE3LDcgQEAgdm9pZCBzY2hlZHVsZV9kdW1w KHN0cnVjdCBjcHVwb29sICpjKQ0KICAgICBzdHJ1Y3Qgc2NoZWR1bGVyICpzY2hlZDsNCiAgICAg Y3B1bWFza190ICAgICAgICAqY3B1czsNCiANCisgICAgLyogUHJvcGVyIGxvY2tpbmcgaXMgcHJv dmlkZWQgYnkgZWFjaCBzY2hlZHVsZXIgKi8NCiAgICAgc2NoZWQgPSAoYyA9PSBOVUxMKSA/ICZv cHMgOiBjLT5zY2hlZDsNCiAgICAgY3B1cyA9IChjID09IE5VTEwpID8gJmNwdXBvb2xfZnJlZV9j cHVzIDogYy0+Y3B1X3ZhbGlkOw0KICAgICBwcmludGsoIlNjaGVkdWxlcjogJXMgKCVzKVxuIiwg c2NoZWQtPm5hbWUsIHNjaGVkLT5vcHRfbmFtZSk7DQpAQCAtMTQyNCwxMCArMTQyNSw4IEBAIHZv aWQgc2NoZWR1bGVfZHVtcChzdHJ1Y3QgY3B1cG9vbCAqYykNCiANCiAgICAgZm9yX2VhY2hfY3B1 IChpLCBjcHVzKQ0KICAgICB7DQotICAgICAgICBwY3B1X3NjaGVkdWxlX2xvY2soaSk7DQogICAg ICAgICBwcmludGsoIkNQVVslMDJkXSAiLCBpKTsNCiAgICAgICAgIFNDSEVEX09QKHNjaGVkLCBk dW1wX2NwdV9zdGF0ZSwgaSk7DQotICAgICAgICBwY3B1X3NjaGVkdWxlX3VubG9jayhpKTsNCiAg ICAgfQ0KIH0NCiANCg== --=-Sn+NDJR3EWzB5LTDsO7k-- --=-ApW/FEYJ2HeKXZmm9mdH 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) iEYEABECAAYFAk8W8lYACgkQk4XaBE3IOsTCcwCfSpGD3WpfK5+Jh5cHvwInLWAV frEAnjm6dykd9QSapwJcKL9cF2dMarti =dxJj -----END PGP SIGNATURE----- --=-ApW/FEYJ2HeKXZmm9mdH-- --===============6363075103574912662== 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 --===============6363075103574912662==--