From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dario Faggioli Subject: [PATCHv2] sedf: remove useless tracing printk and harmonize comments style. Date: Wed, 21 Dec 2011 17:03:45 +0100 Message-ID: <1324483425.4366.43.camel@Abyss> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="===============2284887627372470128==" 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 , Keir Fraser List-Id: xen-devel@lists.xenproject.org --===============2284887627372470128== Content-Type: multipart/signed; micalg="pgp-sha1"; protocol="application/pgp-signature"; boundary="=-oVXZhmqkWYbyP3+4MWM6" --=-oVXZhmqkWYbyP3+4MWM6 Content-Type: multipart/mixed; boundary="=-DM3xwBkUsBWsFUckworM" --=-DM3xwBkUsBWsFUckworM Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable sched_sedf.c used o have its own mechanism for producing tracing-alike kind of information (domain block, wakeup, etc.). Nowadays, with an even not so high number of pCPUs/vCPUs, just trying to enable this makes the serial console completely unusable, produces tons of very hard to parse and interpreet logging and can easily livelock Dom0. Moreover, pretty much the same result this is struggling to get to, is better achieved by enabling the scheduler-related tracing events, as it is for the other schedulers (say, credit or credit2). For all these reasons, this removes that machinery completely. While at it, check in some cosmetics that harmonize the comments withim themself and with the rest of the code base. Signed-off-by: Dario Faggioli diff -r 51045a5ec6bc xen/common/sched_sedf.c --- a/xen/common/sched_sedf.c Wed Dec 21 14:49:01 2011 +0000 +++ b/xen/common/sched_sedf.c Wed Dec 21 15:12:07 2011 +0000 @@ -13,14 +13,6 @@ #include #include =20 -/*verbosity settings*/ -#define SEDFLEVEL 0 -#define PRINT(_f, _a...) \ - do { \ - if ( (_f) <=3D SEDFLEVEL ) \ - printk(_a ); \ - } while ( 0 ) - #define SEDF_CPUONLINE(_pool) = \ (((_pool) =3D=3D NULL) ? &cpupool_free_cpus : (_pool)->cpu_valid) =20 @@ -66,34 +58,35 @@ struct sedf_vcpu_info { struct list_head list; struct list_head extralist[2]; =20 - /*Parameters for EDF*/ - s_time_t period; /*=3D(relative deadline)*/ - s_time_t slice; /*=3Dworst case execution time*/ + /* Parameters for EDF */ + s_time_t period; /* =3D(relative deadline) */ + s_time_t slice; /* =3Dworst case execution time */ =20 - /*Advaced Parameters*/ - /*Latency Scaling*/ + /* Advaced Parameters */ + + /* Latency Scaling */ s_time_t period_orig; s_time_t slice_orig; s_time_t latency; =20 - /*status of domain*/ + /* Status of domain */ int status; - /*weights for "Scheduling for beginners/ lazy/ etc." ;)*/ + /* Weights for "Scheduling for beginners/ lazy/ etc." ;) */ short weight; short extraweight; - /*Bookkeeping*/ + /* Bookkeeping */ s_time_t deadl_abs; s_time_t sched_start_abs; s_time_t cputime; - /* times the domain un-/blocked */ + /* Times the domain un-/blocked */ s_time_t block_abs; s_time_t unblock_abs; =20 - /*scores for {util, block penalty}-weighted extratime distribution*/ + /* Scores for {util, block penalty}-weighted extratime distribution */ int score[2]; s_time_t short_block_lost_tot; =20 - /*Statistics*/ + /* Statistics */ s_time_t extra_time_tot; =20 #ifdef SEDF_STATS @@ -158,18 +151,17 @@ static inline void extraq_del(struct vcp { struct list_head *list =3D EXTRALIST(d,i); ASSERT(extraq_on(d,i)); - PRINT(3, "Removing domain %i.%i from L%i extraq\n", - d->domain->domain_id, d->vcpu_id, i); list_del(list); list->next =3D NULL; ASSERT(!extraq_on(d, i)); } =20 -/* adds a domain to the queue of processes which are aware of extra time. = List - is sorted by score, where a lower score means higher priority for an ex= tra - slice. It also updates the score, by simply subtracting a fixed value f= rom - each entry, in order to avoid overflow. The algorithm works by simply - charging each domain that recieved extratime with an inverse of its wei= ght. +/* + * Adds a domain to the queue of processes which are aware of extra time. = List + * is sorted by score, where a lower score means higher priority for an ex= tra + * slice. It also updates the score, by simply subtracting a fixed value f= rom + * each entry, in order to avoid overflow. The algorithm works by simply + * charging each domain that recieved extratime with an inverse of its wei= ght. */=20 static inline void extraq_add_sort_update(struct vcpu *d, int i, int sub) { @@ -178,11 +170,6 @@ static inline void extraq_add_sort_updat =20 ASSERT(!extraq_on(d,i)); =20 - PRINT(3, "Adding domain %i.%i (score=3D %i, short_pen=3D %"PRIi64")" - " to L%i extraq\n", - d->domain->domain_id, d->vcpu_id, EDOM_INFO(d)->score[i], - EDOM_INFO(d)->short_block_lost_tot, i); - /* * Iterate through all elements to find our "hole" and on our way * update all the other scores. @@ -193,25 +180,18 @@ static inline void extraq_add_sort_updat curinf->score[i] -=3D sub; if ( EDOM_INFO(d)->score[i] < curinf->score[i] ) break; - PRINT(4,"\tbehind domain %i.%i (score=3D %i)\n", - curinf->vcpu->domain->domain_id, - curinf->vcpu->vcpu_id, curinf->score[i]); } =20 - /* cur now contains the element, before which we'll enqueue. */ - PRINT(3, "\tlist_add to %p\n", cur->prev); + /* cur now contains the element, before which we'll enqueue */ list_add(EXTRALIST(d,i),cur->prev); =20 - /* Continue updating the extraq. */ + /* Continue updating the extraq */ if ( (cur !=3D EXTRAQ(d->processor,i)) && sub ) { for ( cur =3D cur->next; cur !=3D EXTRAQ(d->processor,i); cur =3D = cur->next ) { curinf =3D list_entry(cur,struct sedf_vcpu_info, extralist[i])= ; curinf->score[i] -=3D sub; - PRINT(4, "\tupdating domain %i.%i (score=3D %u)\n", - curinf->vcpu->domain->domain_id,=20 - curinf->vcpu->vcpu_id, curinf->score[i]); } } =20 @@ -221,29 +201,14 @@ static inline void extraq_check(struct v { if ( extraq_on(d, EXTRA_UTIL_Q) ) { - PRINT(2,"Dom %i.%i is on L1 extraQ\n", - d->domain->domain_id, d->vcpu_id); - if ( !(EDOM_INFO(d)->status & EXTRA_AWARE) && !extra_runs(EDOM_INFO(d)) ) - { extraq_del(d, EXTRA_UTIL_Q); - PRINT(2,"Removed dom %i.%i from L1 extraQ\n", - d->domain->domain_id, d->vcpu_id); - } } else { - PRINT(2, "Dom %i.%i is NOT on L1 extraQ\n", - d->domain->domain_id, - d->vcpu_id); - if ( (EDOM_INFO(d)->status & EXTRA_AWARE) && sedf_runnable(d) ) - { extraq_add_sort_update(d, EXTRA_UTIL_Q, 0); - PRINT(2,"Added dom %i.%i to L1 extraQ\n", - d->domain->domain_id, d->vcpu_id); - } } } =20 @@ -252,7 +217,7 @@ static inline void extraq_check_add_unbl struct sedf_vcpu_info *inf =3D EDOM_INFO(d); =20 if ( inf->status & EXTRA_AWARE ) - /* Put on the weighted extraq without updating any scores. */ + /* Put on the weighted extraq without updating any scores */ extraq_add_sort_update(d, EXTRA_UTIL_Q, 0); } =20 @@ -265,8 +230,6 @@ static inline void __del_from_queue(stru { struct list_head *list =3D LIST(d); ASSERT(__task_on_queue(d)); - PRINT(3,"Removing domain %i.%i (bop=3D %"PRIu64") from runq/waitq\n", - d->domain->domain_id, d->vcpu_id, PERIOD_BEGIN(EDOM_INFO(d))); list_del(list); list->next =3D NULL; ASSERT(!__task_on_queue(d)); @@ -279,13 +242,12 @@ static inline void list_insert_sort( { struct list_head *cur; =20 - /* Iterate through all elements to find our "hole". */ + /* Iterate through all elements to find our "hole" */ list_for_each( cur, list ) if ( comp(element, cur) < 0 ) break; =20 - /* cur now contains the element, before which we'll enqueue. */ - PRINT(3,"\tlist_add to %p\n",cur->prev); + /* cur now contains the element, before which we'll enqueue */ list_add(element, cur->prev); } =20 @@ -303,30 +265,28 @@ static int name##_comp(struct list_head* return 1; \ } =20 -/* adds a domain to the queue of processes which wait for the beginning of= the - next period; this list is therefore sortet by this time, which is simpl= y - absol. deadline - period +/* + * Adds a domain to the queue of processes which wait for the beginning of= the + * next period; this list is therefore sortet by this time, which is simpl= y + * absol. deadline - period. */=20 DOMAIN_COMPARER(waitq, list, PERIOD_BEGIN(d1), PERIOD_BEGIN(d2)); static inline void __add_to_waitqueue_sort(struct vcpu *v) { ASSERT(!__task_on_queue(v)); - PRINT(3,"Adding domain %i.%i (bop=3D %"PRIu64") to waitq\n", - v->domain->domain_id, v->vcpu_id, PERIOD_BEGIN(EDOM_INFO(v))); list_insert_sort(WAITQ(v->processor), LIST(v), waitq_comp); ASSERT(__task_on_queue(v)); } =20 -/* adds a domain to the queue of processes which have started their curren= t - period and are runnable (i.e. not blocked, dieing,...). The first eleme= nt - on this list is running on the processor, if the list is empty the idle - task will run. As we are implementing EDF, this list is sorted by deadl= ines. +/* + * Adds a domain to the queue of processes which have started their curren= t + * period and are runnable (i.e. not blocked, dieing,...). The first eleme= nt + * on this list is running on the processor, if the list is empty the idle + * task will run. As we are implementing EDF, this list is sorted by deadl= ines. */=20 DOMAIN_COMPARER(runq, list, d1->deadl_abs, d2->deadl_abs); static inline void __add_to_runqueue_sort(struct vcpu *v) { - PRINT(3,"Adding domain %i.%i (deadl=3D %"PRIu64") to runq\n", - v->domain->domain_id, v->vcpu_id, EDOM_INFO(v)->deadl_abs); list_insert_sort(RUNQ(v->processor), LIST(v), runq_comp); } =20 @@ -453,10 +413,10 @@ static void desched_edf_dom(s_time_t now { struct sedf_vcpu_info* inf =3D EDOM_INFO(d); =20 - /* Current domain is running in real time mode. */ + /* Current domain is running in real time mode */ ASSERT(__task_on_queue(d)); =20 - /* Update the domain's cputime. */ + /* Update the domain's cputime */ inf->cputime +=3D now - inf->sched_start_abs; =20 /* @@ -467,7 +427,7 @@ static void desched_edf_dom(s_time_t now return; =20 __del_from_queue(d); - =20 + /* * Manage bookkeeping (i.e. calculate next deadline, memorise * overrun-time of slice) of finished domains. @@ -478,30 +438,30 @@ static void desched_edf_dom(s_time_t now =20 if ( inf->period < inf->period_orig ) { - /* This domain runs in latency scaling or burst mode. */ + /* This domain runs in latency scaling or burst mode */ inf->period *=3D 2; inf->slice *=3D 2; if ( (inf->period > inf->period_orig) || (inf->slice > inf->slice_orig) ) { - /* Reset slice and period. */ + /* Reset slice and period */ inf->period =3D inf->period_orig; inf->slice =3D inf->slice_orig; } } =20 - /* Set next deadline. */ + /* Set next deadline */ inf->deadl_abs +=3D inf->period; } =20 - /* Add a runnable domain to the waitqueue. */ + /* Add a runnable domain to the waitqueue */ if ( sedf_runnable(d) ) { __add_to_waitqueue_sort(d); } else { - /* We have a blocked realtime task -> remove it from exqs too. */ + /* We have a blocked realtime task -> remove it from exqs too */ if ( extraq_on(d, EXTRA_PEN_Q) ) extraq_del(d, EXTRA_PEN_Q); if ( extraq_on(d, EXTRA_UTIL_Q) ) @@ -521,8 +481,6 @@ static void update_queues( struct list_head *cur, *tmp; struct sedf_vcpu_info *curinf; =20 - PRINT(3,"Updating waitq..\n"); - /* * Check for the first elements of the waitqueue, whether their * next period has already started. @@ -530,41 +488,32 @@ static void update_queues( list_for_each_safe ( cur, tmp, waitq ) { curinf =3D list_entry(cur, struct sedf_vcpu_info, list); - PRINT(4,"\tLooking @ dom %i.%i\n", - curinf->vcpu->domain->domain_id, curinf->vcpu->vcpu_id); if ( PERIOD_BEGIN(curinf) > now ) break; __del_from_queue(curinf->vcpu); __add_to_runqueue_sort(curinf->vcpu); } =20 - PRINT(3,"Updating runq..\n"); - - /* Process the runq, find domains that are on the runq that shouldn't.= */ + /* Process the runq, find domains that are on the runq that shouldn't = */ list_for_each_safe ( cur, tmp, runq ) { curinf =3D list_entry(cur,struct sedf_vcpu_info,list); - PRINT(4,"\tLooking @ dom %i.%i\n", - curinf->vcpu->domain->domain_id, curinf->vcpu->vcpu_id); =20 if ( unlikely(curinf->slice =3D=3D 0) ) { - /* Ignore domains with empty slice. */ - PRINT(4,"\tUpdating zero-slice domain %i.%i\n", - curinf->vcpu->domain->domain_id, - curinf->vcpu->vcpu_id); + /* Ignore domains with empty slice */ __del_from_queue(curinf->vcpu); =20 - /* Move them to their next period. */ + /* Move them to their next period */ curinf->deadl_abs +=3D curinf->period; =20 - /* Ensure that the start of the next period is in the future. = */ + /* Ensure that the start of the next period is in the future *= / if ( unlikely(PERIOD_BEGIN(curinf) < now) ) curinf->deadl_abs +=3D=20 (DIV_UP(now - PERIOD_BEGIN(curinf), curinf->period)) * curinf->period; =20 - /* Put them back into the queue. */ + /* Put them back into the queue */ __add_to_waitqueue_sort(curinf->vcpu); } else if ( unlikely((curinf->deadl_abs < now) || @@ -574,18 +523,18 @@ static void update_queues( * We missed the deadline or the slice was already finished. * Might hapen because of dom_adj. */ - PRINT(4,"\tDomain %i.%i exceeded it's deadline/" - "slice (%"PRIu64" / %"PRIu64") now: %"PRIu64 - " cputime: %"PRIu64"\n", - curinf->vcpu->domain->domain_id, - curinf->vcpu->vcpu_id, - curinf->deadl_abs, curinf->slice, now, - curinf->cputime); + printk("\tDomain %i.%i exceeded it's deadline/" + "slice (%"PRIu64" / %"PRIu64") now: %"PRIu64 + " cputime: %"PRIu64"\n", + curinf->vcpu->domain->domain_id, + curinf->vcpu->vcpu_id, + curinf->deadl_abs, curinf->slice, now, + curinf->cputime); __del_from_queue(curinf->vcpu); =20 - /* Common case: we miss one period. */ + /* Common case: we miss one period */ curinf->deadl_abs +=3D curinf->period; - =20 + /* * If we are still behind: modulo arithmetic, force deadline * to be in future and aligned to period borders. @@ -596,7 +545,7 @@ static void update_queues( curinf->period) * curinf->period; ASSERT(curinf->deadl_abs >=3D now); =20 - /* Give a fresh slice. */ + /* Give a fresh slice */ curinf->cputime =3D 0; if ( PERIOD_BEGIN(curinf) > now ) __add_to_waitqueue_sort(curinf->vcpu); @@ -606,17 +555,17 @@ static void update_queues( else break; } - - PRINT(3,"done updating the queues\n"); } =20 -/* removes a domain from the head of the according extraQ and - requeues it at a specified position: - round-robin extratime: end of extraQ - weighted ext.: insert in sorted list by score - if the domain is blocked / has regained its short-block-loss - time it is not put on any queue */ +/* + * removes a domain from the head of the according extraQ and + * requeues it at a specified position: + * round-robin extratime: end of extraQ + * weighted ext.: insert in sorted list by score + * if the domain is blocked / has regained its short-block-loss + * time it is not put on any queue. + */ static void desched_extra_dom(s_time_t now, struct vcpu *d) { struct sedf_vcpu_info *inf =3D EDOM_INFO(d); @@ -625,29 +574,25 @@ static void desched_extra_dom(s_time_t n =20 ASSERT(extraq_on(d, i)); =20 - /* Unset all running flags. */ + /* Unset all running flags */ inf->status &=3D ~(EXTRA_RUN_PEN | EXTRA_RUN_UTIL); - /* Fresh slice for the next run. */ + /* Fresh slice for the next run */ inf->cputime =3D 0; - /* Accumulate total extratime. */ + /* Accumulate total extratime */ inf->extra_time_tot +=3D now - inf->sched_start_abs; /* Remove extradomain from head of the queue. */ extraq_del(d, i); =20 - /* Update the score. */ + /* Update the score */ oldscore =3D inf->score[i]; if ( i =3D=3D EXTRA_PEN_Q ) { - /*domain was running in L0 extraq*/ - /*reduce block lost, probably more sophistication here!*/ + /* Domain was running in L0 extraq */ + /* reduce block lost, probably more sophistication here!*/ /*inf->short_block_lost_tot -=3D EXTRA_QUANTUM;*/ inf->short_block_lost_tot -=3D now - inf->sched_start_abs; - PRINT(3,"Domain %i.%i: Short_block_loss: %"PRIi64"\n",=20 - inf->vcpu->domain->domain_id, inf->vcpu->vcpu_id, - inf->short_block_lost_tot); #if 0 - /* - * KAF: If we don't exit short-blocking state at this point + /* KAF: If we don't exit short-blocking state at this point * domain0 can steal all CPU for up to 10 seconds before * scheduling settles down (when competing against another * CPU-bound domain). Doing this seems to make things behave @@ -656,51 +601,59 @@ static void desched_extra_dom(s_time_t n if ( inf->short_block_lost_tot <=3D 0 ) #endif { - PRINT(4,"Domain %i.%i compensated short block loss!\n", - inf->vcpu->domain->domain_id, inf->vcpu->vcpu_id); - /*we have (over-)compensated our block penalty*/ + /* We have (over-)compensated our block penalty */ inf->short_block_lost_tot =3D 0; - /*we don't want a place on the penalty queue anymore!*/ + /* We don't want a place on the penalty queue anymore! */ inf->status &=3D ~EXTRA_WANT_PEN_Q; goto check_extra_queues; } =20 - /*we have to go again for another try in the block-extraq, - the score is not used incremantally here, as this is - already done by recalculating the block_lost*/ + /* + * We have to go again for another try in the block-extraq, + * the score is not used incremantally here, as this is + * already done by recalculating the block_lost + */ inf->score[EXTRA_PEN_Q] =3D (inf->period << 10) / inf->short_block_lost_tot; oldscore =3D 0; } else { - /*domain was running in L1 extraq =3D> score is inverse of - utilization and is used somewhat incremental!*/ + /* + * Domain was running in L1 extraq =3D> score is inverse of + * utilization and is used somewhat incremental! + */ if ( !inf->extraweight ) - /*NB: use fixed point arithmetic with 10 bits*/ + { + /* NB: use fixed point arithmetic with 10 bits */ inf->score[EXTRA_UTIL_Q] =3D (inf->period << 10) / inf->slice; + } else - /*conversion between realtime utilisation and extrawieght: - full (ie 100%) utilization is equivalent to 128 extraweight*= / + { + /* + * Conversion between realtime utilisation and extrawieght: + * full (ie 100%) utilization is equivalent to 128 extraweight + */ inf->score[EXTRA_UTIL_Q] =3D (1<<17) / inf->extraweight; + } } =20 check_extra_queues: - /* Adding a runnable domain to the right queue and removing blocked on= es*/ + /* Adding a runnable domain to the right queue and removing blocked on= es */ if ( sedf_runnable(d) ) { - /*add according to score: weighted round robin*/ + /* Add according to score: weighted round robin */ if (((inf->status & EXTRA_AWARE) && (i =3D=3D EXTRA_UTIL_Q)) || ((inf->status & EXTRA_WANT_PEN_Q) && (i =3D=3D EXTRA_PEN_Q))) extraq_add_sort_update(d, i, oldscore); } else { - /*remove this blocked domain from the waitq!*/ + /* Remove this blocked domain from the waitq! */ __del_from_queue(d); - /*make sure that we remove a blocked domain from the other - extraq too*/ + /* Make sure that we remove a blocked domain from the other + * extraq too. */ if ( i =3D=3D EXTRA_PEN_Q ) { if ( extraq_on(d, EXTRA_UTIL_Q) ) @@ -732,8 +685,10 @@ static struct task_slice sedf_do_extra_s =20 if ( !list_empty(extraq[EXTRA_PEN_Q]) ) { - /*we still have elements on the level 0 extraq=20 - =3D> let those run first!*/ + /* + * We still have elements on the level 0 extraq + * =3D> let those run first! + */ runinf =3D list_entry(extraq[EXTRA_PEN_Q]->next,=20 struct sedf_vcpu_info, extralist[EXTRA_PEN_Q= ]); runinf->status |=3D EXTRA_RUN_PEN; @@ -747,7 +702,7 @@ static struct task_slice sedf_do_extra_s { if ( !list_empty(extraq[EXTRA_UTIL_Q]) ) { - /*use elements from the normal extraqueue*/ + /* Use elements from the normal extraqueue */ runinf =3D list_entry(extraq[EXTRA_UTIL_Q]->next, struct sedf_vcpu_info, extralist[EXTRA_UTIL_Q]); @@ -772,11 +727,13 @@ static struct task_slice sedf_do_extra_s } =20 -/* Main scheduling function - Reasons for calling this function are: - -timeslice for the current period used up - -domain on waitqueue has started it's period - -and various others ;) in general: determine which domain to run next*/ +/* + * Main scheduling function + * Reasons for calling this function are: + * -timeslice for the current period used up + * -domain on waitqueue has started it's period + * -and various others ;) in general: determine which domain to run next + */ static struct task_slice sedf_do_schedule( const struct scheduler *ops, s_time_t now, bool_t tasklet_work_schedul= ed) { @@ -789,13 +746,15 @@ static struct task_slice sedf_do_schedul struct sedf_vcpu_info *runinf, *waitinf; struct task_slice ret; =20 - /*idle tasks don't need any of the following stuf*/ + /* Idle tasks don't need any of the following stuf */ if ( is_idle_vcpu(current) ) goto check_waitq; -=20 - /* create local state of the status of the domain, in order to avoid - inconsistent state during scheduling decisions, because data for - vcpu_runnable is not protected by the scheduling lock!*/ + + /* + * Create local state of the status of the domain, in order to avoid + * inconsistent state during scheduling decisions, because data for + * vcpu_runnable is not protected by the scheduling lock! + */ if ( !vcpu_runnable(current) ) inf->status |=3D SEDF_ASLEEP; =20 @@ -804,7 +763,7 @@ static struct task_slice sedf_do_schedul =20 if ( unlikely(extra_runs(inf)) ) { - /*special treatment of domains running in extra time*/ + /* Special treatment of domains running in extra time */ desched_extra_dom(now, current); } else=20 @@ -814,10 +773,12 @@ static struct task_slice sedf_do_schedul check_waitq: update_queues(now, runq, waitq); =20 - /*now simply pick the first domain from the runqueue, which has the - earliest deadline, because the list is sorted*/ -=20 - /* Tasklet work (which runs in idle VCPU context) overrides all else. = */ + /* + * Now simply pick the first domain from the runqueue, which has the + * earliest deadline, because the list is sorted + * + * Tasklet work (which runs in idle VCPU context) overrides all else. + */ if ( tasklet_work_scheduled || (list_empty(runq) && list_empty(waitq)) || unlikely(!cpumask_test_cpu(cpu, SEDF_CPUONLINE(per_cpu(cpupool, c= pu)))) ) @@ -833,9 +794,11 @@ static struct task_slice sedf_do_schedul { waitinf =3D list_entry(waitq->next, struct sedf_vcpu_info,list); - /*rerun scheduler, when scheduled domain reaches it's - end of slice or the first domain from the waitqueue - gets ready*/ + /* + * Rerun scheduler, when scheduled domain reaches it's + * end of slice or the first domain from the waitqueue + * gets ready. + */ ret.time =3D MIN(now + runinf->slice - runinf->cputime, PERIOD_BEGIN(waitinf)) - now; } @@ -847,14 +810,18 @@ static struct task_slice sedf_do_schedul else { waitinf =3D list_entry(waitq->next,struct sedf_vcpu_info, list); - /*we could not find any suitable domain=20 - =3D> look for domains that are aware of extratime*/ + /* + * We could not find any suitable domain=20 + * =3D> look for domains that are aware of extratime + */ ret =3D sedf_do_extra_schedule(now, PERIOD_BEGIN(waitinf), extraq, cpu); } =20 - /*TODO: Do something USEFUL when this happens and find out, why it - still can happen!!!*/ + /* + * TODO: Do something USEFUL when this happens and find out, why it + * still can happen!!! + */ if ( ret.time < 0) { printk("Ouch! We are seriously BEHIND schedule! %"PRIi64"\n", @@ -874,9 +841,6 @@ static struct task_slice sedf_do_schedul =20 static void sedf_sleep(const struct scheduler *ops, struct vcpu *d) { - PRINT(2,"sedf_sleep was called, domain-id %i.%i\n", - d->domain->domain_id, d->vcpu_id); -=20 if ( is_idle_vcpu(d) ) return; =20 @@ -898,7 +862,8 @@ static void sedf_sleep(const struct sche } =20 -/* This function wakes up a domain, i.e. moves them into the waitqueue +/* + * This function wakes up a domain, i.e. moves them into the waitqueue * things to mention are: admission control is taking place nowhere at * the moment, so we can't be sure, whether it is safe to wake the domain * up at all. Anyway, even if it is safe (total cpu usage <=3D100%) there = are @@ -972,27 +937,31 @@ static void sedf_sleep(const struct sche static void unblock_short_extra_support( struct sedf_vcpu_info* inf, s_time_t now) { - /*this unblocking scheme tries to support the domain, by assigning it - a priority in extratime distribution according to the loss of time - in this slice due to blocking*/ + /* + * This unblocking scheme tries to support the domain, by assigning it + * a priority in extratime distribution according to the loss of time + * in this slice due to blocking + */ s_time_t pen; =20 - /*no more realtime execution in this period!*/ + /* No more realtime execution in this period! */ inf->deadl_abs +=3D inf->period; if ( likely(inf->block_abs) ) { - //treat blocked time as consumed by the domain*/ + /* Treat blocked time as consumed by the domain */ /*inf->cputime +=3D now - inf->block_abs;*/ - /*penalty is time the domain would have - had if it continued to run */ + /* + * Penalty is time the domain would have + * had if it continued to run. + */ pen =3D (inf->slice - inf->cputime); if ( pen < 0 ) pen =3D 0; - /*accumulate all penalties over the periods*/ + /* Accumulate all penalties over the periods */ /*inf->short_block_lost_tot +=3D pen;*/ - /*set penalty to the current value*/ + /* Set penalty to the current value */ inf->short_block_lost_tot =3D pen; - /*not sure which one is better.. but seems to work well...*/ + /* Not sure which one is better.. but seems to work well... */ =20 if ( inf->short_block_lost_tot ) { @@ -1002,28 +971,31 @@ static void unblock_short_extra_support( inf->pen_extra_blocks++; #endif if ( extraq_on(inf->vcpu, EXTRA_PEN_Q) ) - /*remove domain for possible resorting!*/ + /* Remove domain for possible resorting! */ extraq_del(inf->vcpu, EXTRA_PEN_Q); else - /*remember that we want to be on the penalty q - so that we can continue when we (un-)block - in penalty-extratime*/ + /* + * Remember that we want to be on the penalty q + * so that we can continue when we (un-)block + * in penalty-extratime + */ inf->status |=3D EXTRA_WANT_PEN_Q; =20 - /*(re-)add domain to the penalty extraq*/ + /* (re-)add domain to the penalty extraq */ extraq_add_sort_update(inf->vcpu, EXTRA_PEN_Q, 0); } } =20 - /*give it a fresh slice in the next period!*/ + /* Give it a fresh slice in the next period! */ inf->cputime =3D 0; } =20 static void unblock_long_cons_b(struct sedf_vcpu_info* inf,s_time_t now) { - /*Conservative 2b*/ - /*Treat the unblocking time as a start of a new period */ + /* Conservative 2b */ + + /* Treat the unblocking time as a start of a new period */ inf->deadl_abs =3D now + inf->period; inf->cputime =3D 0; } @@ -1046,15 +1018,17 @@ static inline int get_run_type(struct vc } =20 -/*Compares two domains in the relation of whether the one is allowed to - interrupt the others execution. - It returns true (!=3D0) if a switch to the other domain is good. - Current Priority scheme is as follows: - EDF > L0 (penalty based) extra-time >=20 - L1 (utilization) extra-time > idle-domain - In the same class priorities are assigned as following: - EDF: early deadline > late deadline - L0 extra-time: lower score > higher score*/ +/* + * Compares two domains in the relation of whether the one is allowed to + * interrupt the others execution. + * It returns true (!=3D0) if a switch to the other domain is good. + * Current Priority scheme is as follows: + * EDF > L0 (penalty based) extra-time >=20 + * L1 (utilization) extra-time > idle-domain + * In the same class priorities are assigned as following: + * EDF: early deadline > late deadline + * L0 extra-time: lower score > higher score + */ static inline int should_switch(struct vcpu *cur, struct vcpu *other, s_time_t now) @@ -1063,26 +1037,25 @@ static inline int should_switch(struct v cur_inf =3D EDOM_INFO(cur); other_inf =3D EDOM_INFO(other); =20 - /* Check whether we need to make an earlier scheduling decision. */ + /* Check whether we need to make an earlier scheduling decision */ if ( PERIOD_BEGIN(other_inf) <=20 CPU_INFO(other->processor)->current_slice_expires ) return 1; =20 - /* No timing-based switches need to be taken into account here. */ + /* No timing-based switches need to be taken into account here */ switch ( get_run_type(cur) ) { case DOMAIN_EDF: - /* Do not interrupt a running EDF domain. */ + /* Do not interrupt a running EDF domain */ return 0; case DOMAIN_EXTRA_PEN: - /* Check whether we also want the L0 ex-q with lower score. */ + /* Check whether we also want the L0 ex-q with lower score */ return ((other_inf->status & EXTRA_WANT_PEN_Q) && (other_inf->score[EXTRA_PEN_Q] <=20 cur_inf->score[EXTRA_PEN_Q])); case DOMAIN_EXTRA_UTIL: /* Check whether we want the L0 extraq. Don't - * switch if both domains want L1 extraq. - */ + * switch if both domains want L1 extraq. */ return !!(other_inf->status & EXTRA_WANT_PEN_Q); case DOMAIN_IDLE: return 1; @@ -1096,18 +1069,11 @@ static void sedf_wake(const struct sched s_time_t now =3D NOW(); struct sedf_vcpu_info* inf =3D EDOM_INFO(d); =20 - PRINT(3, "sedf_wake was called, domain-id %i.%i\n",d->domain->domain_i= d, - d->vcpu_id); - if ( unlikely(is_idle_vcpu(d)) ) return; =20 if ( unlikely(__task_on_queue(d)) ) - { - PRINT(3,"\tdomain %i.%i is already in some queue\n", - d->domain->domain_id, d->vcpu_id); return; - } =20 ASSERT(!sedf_runnable(d)); inf->status &=3D ~SEDF_ASLEEP; @@ -1116,28 +1082,25 @@ static void sedf_wake(const struct sched =20 if ( unlikely(inf->deadl_abs =3D=3D 0) ) { - /*initial setup of the deadline*/ + /* Initial setup of the deadline */ inf->deadl_abs =3D now + inf->slice; } =20 - PRINT(3, "waking up domain %i.%i (deadl=3D %"PRIu64" period=3D %"PRIu6= 4 - "now=3D %"PRIu64")\n", - d->domain->domain_id, d->vcpu_id, inf->deadl_abs, inf->period, n= ow); - #ifdef SEDF_STATS=20 inf->block_tot++; #endif =20 if ( unlikely(now < PERIOD_BEGIN(inf)) ) { - PRINT(4,"extratime unblock\n"); - /* unblocking in extra-time! */ + /* Unblocking in extra-time! */ if ( inf->status & EXTRA_WANT_PEN_Q ) { - /*we have a domain that wants compensation - for block penalty and did just block in - its compensation time. Give it another - chance!*/ + /* + * We have a domain that wants compensation + * for block penalty and did just block in + * its compensation time. Give it another + * chance! + */ extraq_add_sort_update(d, EXTRA_PEN_Q, 0); } extraq_check_add_unblocked(d, 0); @@ -1146,8 +1109,7 @@ static void sedf_wake(const struct sched { =20 if ( now < inf->deadl_abs ) { - PRINT(4,"short unblocking\n"); - /*short blocking*/ + /* Short blocking */ #ifdef SEDF_STATS inf->short_block_tot++; #endif @@ -1157,8 +1119,7 @@ static void sedf_wake(const struct sched } else { - PRINT(4,"long unblocking\n"); - /*long unblocking*/ + /* Long unblocking */ #ifdef SEDF_STATS inf->long_block_tot++; #endif @@ -1168,24 +1129,13 @@ static void sedf_wake(const struct sched } } =20 - PRINT(3, "woke up domain %i.%i (deadl=3D %"PRIu64" period=3D %"PRIu64 - "now=3D %"PRIu64")\n", - d->domain->domain_id, d->vcpu_id, inf->deadl_abs, - inf->period, now); - if ( PERIOD_BEGIN(inf) > now ) - { __add_to_waitqueue_sort(d); - PRINT(3,"added to waitq\n"); - } else - { __add_to_runqueue_sort(d); - PRINT(3,"added to runq\n"); - } =20 #ifdef SEDF_STATS - /*do some statistics here...*/ + /* Do some statistics here... */ if ( inf->block_abs !=3D 0 ) { inf->block_time_tot +=3D now - inf->block_abs; @@ -1194,12 +1144,14 @@ static void sedf_wake(const struct sched } #endif =20 - /*sanity check: make sure each extra-aware domain IS on the util-q!*/ + /* Sanity check: make sure each extra-aware domain IS on the util-q! *= / ASSERT(IMPLY(inf->status & EXTRA_AWARE, extraq_on(d, EXTRA_UTIL_Q))); ASSERT(__task_on_queue(d)); - /*check whether the awakened task needs to invoke the do_schedule - routine. Try to avoid unnecessary runs but: - Save approximation: Always switch to scheduler!*/ + /* + * Check whether the awakened task needs to invoke the do_schedule + * routine. Try to avoid unnecessary runs but: + * Save approximation: Always switch to scheduler! + */ ASSERT(d->processor >=3D 0); ASSERT(d->processor < nr_cpu_ids); ASSERT(per_cpu(schedule_data, d->processor).curr); @@ -1244,7 +1196,7 @@ static void sedf_dump_domain(struct vcpu } =20 -/* dumps all domains on the specified cpu */ +/* Dumps all domains on the specified cpu */ static void sedf_dump_cpu_state(const struct scheduler *ops, int i) { struct list_head *list, *queue, *tmp; @@ -1319,7 +1271,7 @@ static void sedf_dump_cpu_state(const st } =20 -/* Adjusts periods and slices of the domains accordingly to their weights.= */ +/* 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) { struct vcpu *p; @@ -1335,7 +1287,7 @@ static int sedf_adjust_weights(struct cp return -ENOMEM; } =20 - /* Sum across all weights. */ + /* Sum across all weights */ rcu_read_lock(&domlist_read_lock); for_each_domain_in_cpupool( d, c ) { @@ -1350,11 +1302,14 @@ static int sedf_adjust_weights(struct cp } else { - /*don't modify domains who don't have a weight, but sum - up the time they need, projected to a WEIGHT_PERIOD, - so that this time is not given to the weight-driven - domains*/ - /*check for overflows*/ + /* + * Don't modify domains who don't have a weight, but sum + * up the time they need, projected to a WEIGHT_PERIOD, + * so that this time is not given to the weight-driven + * domains + */ + + /* Check for overflows */ ASSERT((WEIGHT_PERIOD < ULONG_MAX)=20 && (EDOM_INFO(p)->slice_orig < ULONG_MAX)); sumt[cpu] +=3D=20 @@ -1365,7 +1320,7 @@ 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 */ rcu_read_lock(&domlist_read_lock); for_each_domain_in_cpupool( d, c ) { @@ -1393,20 +1348,15 @@ static int sedf_adjust_weights(struct cp } =20 -/* set or fetch domain scheduling parameters */ +/* 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 vcpu *v; int rc; =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"); - if ( op->cmd =3D=3D XEN_DOMCTL_SCHEDOP_putinfo ) { - /* Check for sane parameters. */ + /* Check for sane parameters */ if ( !op->u.sedf.period && !op->u.sedf.weight ) return -EINVAL; if ( op->u.sedf.weight ) @@ -1414,7 +1364,7 @@ static int sedf_adjust(const struct sche if ( (op->u.sedf.extratime & EXTRA_AWARE) && (!op->u.sedf.period) ) { - /* Weight-driven domains with extratime only. */ + /* Weight-driven domains with extratime only */ for_each_vcpu ( p, v ) { EDOM_INFO(v)->extraweight =3D op->u.sedf.weight; @@ -1425,7 +1375,7 @@ static int sedf_adjust(const struct sche } else { - /* Weight-driven domains with real-time execution. */ + /* Weight-driven domains with real-time execution */ for_each_vcpu ( p, v ) EDOM_INFO(v)->weight =3D op->u.sedf.weight; } @@ -1477,7 +1427,6 @@ 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; } =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) --=-DM3xwBkUsBWsFUckworM Content-Disposition: attachment; filename="sedf-debug-cleanup.patch" Content-Type: text/x-patch; name="sedf-debug-cleanup.patch"; charset="UTF-8" Content-Transfer-Encoding: base64 IyBIRyBjaGFuZ2VzZXQgcGF0Y2gNCiMgUGFyZW50IDUxMDQ1YTVlYzZiY2YxZTk3NDU4ZTRlNzQ3 ZDUyYmNjYjA3MzQ4YTQNCnNlZGY6IHJlbW92ZSB1c2VsZXNzIHRyYWNpbmcgcHJpbnRrIGFuZCBo YXJtb25pemUgY29tbWVudHMgc3R5bGUuDQoNCnNjaGVkX3NlZGYuYyB1c2VkIG8gaGF2ZSBpdHMg b3duIG1lY2hhbmlzbSBmb3IgcHJvZHVjaW5nIHRyYWNpbmctYWxpa2UNCmtpbmQgb2YgaW5mb3Jt YXRpb24gKGRvbWFpbiBibG9jaywgd2FrZXVwLCBldGMuKS4gTm93YWRheXMsIHdpdGggYW4gZXZl bg0Kbm90IHNvIGhpZ2ggbnVtYmVyIG9mIHBDUFVzL3ZDUFVzLCBqdXN0IHRyeWluZyB0byBlbmFi bGUgdGhpcyBtYWtlcw0KdGhlIHNlcmlhbCBjb25zb2xlIGNvbXBsZXRlbHkgdW51c2FibGUsIHBy b2R1Y2VzIHRvbnMgb2YgdmVyeSBoYXJkIHRvDQpwYXJzZSBhbmQgaW50ZXJwcmVldCBsb2dnaW5n IGFuZCBjYW4gZWFzaWx5IGxpdmVsb2NrIERvbTAuIE1vcmVvdmVyLA0KcHJldHR5IG11Y2ggdGhl IHNhbWUgcmVzdWx0IHRoaXMgaXMgc3RydWdnbGluZyB0byBnZXQgdG8sIGlzIGJldHRlcg0KYWNo aWV2ZWQgYnkgZW5hYmxpbmcgdGhlIHNjaGVkdWxlci1yZWxhdGVkIHRyYWNpbmcgZXZlbnRzLCBh cw0KaXQgaXMgZm9yIHRoZSBvdGhlciBzY2hlZHVsZXJzIChzYXksIGNyZWRpdCBvciBjcmVkaXQy KS4NCg0KRm9yIGFsbCB0aGVzZSByZWFzb25zLCB0aGlzIHJlbW92ZXMgdGhhdCBtYWNoaW5lcnkg Y29tcGxldGVseS4gV2hpbGUgYXQNCml0LCBjaGVjayBpbiBzb21lIGNvc21ldGljcyB0aGF0IGhh cm1vbml6ZSB0aGUgY29tbWVudHMgd2l0aGltIHRoZW1zZWxmDQphbmQgd2l0aCB0aGUgcmVzdCBv ZiB0aGUgY29kZSBiYXNlLg0KDQpTaWduZWQtb2ZmLWJ5OiBEYXJpbyBGYWdnaW9saSA8ZGFyaW8u ZmFnZ2lvbGlAY2l0cml4LmNvbT4NCg0KZGlmZiAtciA1MTA0NWE1ZWM2YmMgeGVuL2NvbW1vbi9z Y2hlZF9zZWRmLmMNCi0tLSBhL3hlbi9jb21tb24vc2NoZWRfc2VkZi5jCVdlZCBEZWMgMjEgMTQ6 NDk6MDEgMjAxMSArMDAwMA0KKysrIGIveGVuL2NvbW1vbi9zY2hlZF9zZWRmLmMJV2VkIERlYyAy MSAxNToxMjowNyAyMDExICswMDAwDQpAQCAtMTMsMTQgKzEzLDYgQEANCiAjaW5jbHVkZSA8eGVu L3RpbWUuaD4NCiAjaW5jbHVkZSA8eGVuL2Vycm5vLmg+DQogDQotLyp2ZXJib3NpdHkgc2V0dGlu Z3MqLw0KLSNkZWZpbmUgU0VERkxFVkVMIDANCi0jZGVmaW5lIFBSSU5UKF9mLCBfYS4uLikgICAg ICAgICAgICAgICAgICAgICAgICBcDQotICAgIGRvIHsgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgXA0KLSAgICAgICAgaWYgKCAoX2YpIDw9IFNFREZMRVZFTCApICAgICAg ICAgICAgICAgIFwNCi0gICAgICAgICAgICBwcmludGsoX2EgKTsgICAgICAgICAgICAgICAgICAg ICAgICBcDQotICAgIH0gd2hpbGUgKCAwICkNCi0NCiAjZGVmaW5lIFNFREZfQ1BVT05MSU5FKF9w b29sKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwNCiAgICAg KCgoX3Bvb2wpID09IE5VTEwpID8gJmNwdXBvb2xfZnJlZV9jcHVzIDogKF9wb29sKS0+Y3B1X3Zh bGlkKQ0KIA0KQEAgLTY2LDM0ICs1OCwzNSBAQCBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8gew0KICAg ICBzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7DQogICAgIHN0cnVjdCBsaXN0X2hlYWQgZXh0cmFsaXN0 WzJdOw0KICANCi0gICAgLypQYXJhbWV0ZXJzIGZvciBFREYqLw0KLSAgICBzX3RpbWVfdCAgcGVy aW9kOyAgLyo9KHJlbGF0aXZlIGRlYWRsaW5lKSovDQotICAgIHNfdGltZV90ICBzbGljZTsgIC8q PXdvcnN0IGNhc2UgZXhlY3V0aW9uIHRpbWUqLw0KKyAgICAvKiBQYXJhbWV0ZXJzIGZvciBFREYg Ki8NCisgICAgc190aW1lX3QgIHBlcmlvZDsgIC8qID0ocmVsYXRpdmUgZGVhZGxpbmUpICovDQor ICAgIHNfdGltZV90ICBzbGljZTsgICAvKiA9d29yc3QgY2FzZSBleGVjdXRpb24gdGltZSAqLw0K ICANCi0gICAgLypBZHZhY2VkIFBhcmFtZXRlcnMqLw0KLSAgICAvKkxhdGVuY3kgU2NhbGluZyov DQorICAgIC8qIEFkdmFjZWQgUGFyYW1ldGVycyAqLw0KKw0KKyAgICAvKiBMYXRlbmN5IFNjYWxp bmcgKi8NCiAgICAgc190aW1lX3QgIHBlcmlvZF9vcmlnOw0KICAgICBzX3RpbWVfdCAgc2xpY2Vf b3JpZzsNCiAgICAgc190aW1lX3QgIGxhdGVuY3k7DQogIA0KLSAgICAvKnN0YXR1cyBvZiBkb21h aW4qLw0KKyAgICAvKiBTdGF0dXMgb2YgZG9tYWluICovDQogICAgIGludCAgICAgICBzdGF0dXM7 DQotICAgIC8qd2VpZ2h0cyBmb3IgIlNjaGVkdWxpbmcgZm9yIGJlZ2lubmVycy8gbGF6eS8gZXRj LiIgOykqLw0KKyAgICAvKiBXZWlnaHRzIGZvciAiU2NoZWR1bGluZyBmb3IgYmVnaW5uZXJzLyBs YXp5LyBldGMuIiA7KSAqLw0KICAgICBzaG9ydCAgICAgd2VpZ2h0Ow0KICAgICBzaG9ydCAgICAg ZXh0cmF3ZWlnaHQ7DQotICAgIC8qQm9va2tlZXBpbmcqLw0KKyAgICAvKiBCb29ra2VlcGluZyAq Lw0KICAgICBzX3RpbWVfdCAgZGVhZGxfYWJzOw0KICAgICBzX3RpbWVfdCAgc2NoZWRfc3RhcnRf YWJzOw0KICAgICBzX3RpbWVfdCAgY3B1dGltZTsNCi0gICAgLyogdGltZXMgdGhlIGRvbWFpbiB1 bi0vYmxvY2tlZCAqLw0KKyAgICAvKiBUaW1lcyB0aGUgZG9tYWluIHVuLS9ibG9ja2VkICovDQog ICAgIHNfdGltZV90ICBibG9ja19hYnM7DQogICAgIHNfdGltZV90ICB1bmJsb2NrX2FiczsNCiAg DQotICAgIC8qc2NvcmVzIGZvciB7dXRpbCwgYmxvY2sgcGVuYWx0eX0td2VpZ2h0ZWQgZXh0cmF0 aW1lIGRpc3RyaWJ1dGlvbiovDQorICAgIC8qIFNjb3JlcyBmb3Ige3V0aWwsIGJsb2NrIHBlbmFs dHl9LXdlaWdodGVkIGV4dHJhdGltZSBkaXN0cmlidXRpb24gKi8NCiAgICAgaW50ICAgc2NvcmVb Ml07DQogICAgIHNfdGltZV90ICBzaG9ydF9ibG9ja19sb3N0X3RvdDsNCiAgDQotICAgIC8qU3Rh dGlzdGljcyovDQorICAgIC8qIFN0YXRpc3RpY3MgKi8NCiAgICAgc190aW1lX3QgIGV4dHJhX3Rp bWVfdG90Ow0KIA0KICNpZmRlZiBTRURGX1NUQVRTDQpAQCAtMTU4LDE4ICsxNTEsMTcgQEAgc3Rh dGljIGlubGluZSB2b2lkIGV4dHJhcV9kZWwoc3RydWN0IHZjcA0KIHsNCiAgICAgc3RydWN0IGxp c3RfaGVhZCAqbGlzdCA9IEVYVFJBTElTVChkLGkpOw0KICAgICBBU1NFUlQoZXh0cmFxX29uKGQs aSkpOw0KLSAgICBQUklOVCgzLCAiUmVtb3ZpbmcgZG9tYWluICVpLiVpIGZyb20gTCVpIGV4dHJh cVxuIiwNCi0gICAgICAgICAgZC0+ZG9tYWluLT5kb21haW5faWQsIGQtPnZjcHVfaWQsIGkpOw0K ICAgICBsaXN0X2RlbChsaXN0KTsNCiAgICAgbGlzdC0+bmV4dCA9IE5VTEw7DQogICAgIEFTU0VS VCghZXh0cmFxX29uKGQsIGkpKTsNCiB9DQogDQotLyogYWRkcyBhIGRvbWFpbiB0byB0aGUgcXVl dWUgb2YgcHJvY2Vzc2VzIHdoaWNoIGFyZSBhd2FyZSBvZiBleHRyYSB0aW1lLiBMaXN0DQotICAg aXMgc29ydGVkIGJ5IHNjb3JlLCB3aGVyZSBhIGxvd2VyIHNjb3JlIG1lYW5zIGhpZ2hlciBwcmlv cml0eSBmb3IgYW4gZXh0cmENCi0gICBzbGljZS4gSXQgYWxzbyB1cGRhdGVzIHRoZSBzY29yZSwg Ynkgc2ltcGx5IHN1YnRyYWN0aW5nIGEgZml4ZWQgdmFsdWUgZnJvbQ0KLSAgIGVhY2ggZW50cnks IGluIG9yZGVyIHRvIGF2b2lkIG92ZXJmbG93LiBUaGUgYWxnb3JpdGhtIHdvcmtzIGJ5IHNpbXBs eQ0KLSAgIGNoYXJnaW5nIGVhY2ggZG9tYWluIHRoYXQgcmVjaWV2ZWQgZXh0cmF0aW1lIHdpdGgg YW4gaW52ZXJzZSBvZiBpdHMgd2VpZ2h0Lg0KKy8qDQorICogQWRkcyBhIGRvbWFpbiB0byB0aGUg cXVldWUgb2YgcHJvY2Vzc2VzIHdoaWNoIGFyZSBhd2FyZSBvZiBleHRyYSB0aW1lLiBMaXN0DQor ICogaXMgc29ydGVkIGJ5IHNjb3JlLCB3aGVyZSBhIGxvd2VyIHNjb3JlIG1lYW5zIGhpZ2hlciBw cmlvcml0eSBmb3IgYW4gZXh0cmENCisgKiBzbGljZS4gSXQgYWxzbyB1cGRhdGVzIHRoZSBzY29y ZSwgYnkgc2ltcGx5IHN1YnRyYWN0aW5nIGEgZml4ZWQgdmFsdWUgZnJvbQ0KKyAqIGVhY2ggZW50 cnksIGluIG9yZGVyIHRvIGF2b2lkIG92ZXJmbG93LiBUaGUgYWxnb3JpdGhtIHdvcmtzIGJ5IHNp bXBseQ0KKyAqIGNoYXJnaW5nIGVhY2ggZG9tYWluIHRoYXQgcmVjaWV2ZWQgZXh0cmF0aW1lIHdp dGggYW4gaW52ZXJzZSBvZiBpdHMgd2VpZ2h0Lg0KICAqLyANCiBzdGF0aWMgaW5saW5lIHZvaWQg ZXh0cmFxX2FkZF9zb3J0X3VwZGF0ZShzdHJ1Y3QgdmNwdSAqZCwgaW50IGksIGludCBzdWIpDQog ew0KQEAgLTE3OCwxMSArMTcwLDYgQEAgc3RhdGljIGlubGluZSB2b2lkIGV4dHJhcV9hZGRfc29y dF91cGRhdA0KICANCiAgICAgQVNTRVJUKCFleHRyYXFfb24oZCxpKSk7DQogDQotICAgIFBSSU5U KDMsICJBZGRpbmcgZG9tYWluICVpLiVpIChzY29yZT0gJWksIHNob3J0X3Blbj0gJSJQUklpNjQi KSINCi0gICAgICAgICAgIiB0byBMJWkgZXh0cmFxXG4iLA0KLSAgICAgICAgICBkLT5kb21haW4t PmRvbWFpbl9pZCwgZC0+dmNwdV9pZCwgRURPTV9JTkZPKGQpLT5zY29yZVtpXSwNCi0gICAgICAg ICAgRURPTV9JTkZPKGQpLT5zaG9ydF9ibG9ja19sb3N0X3RvdCwgaSk7DQotDQogICAgIC8qDQog ICAgICAqIEl0ZXJhdGUgdGhyb3VnaCBhbGwgZWxlbWVudHMgdG8gZmluZCBvdXIgImhvbGUiIGFu ZCBvbiBvdXIgd2F5DQogICAgICAqIHVwZGF0ZSBhbGwgdGhlIG90aGVyIHNjb3Jlcy4NCkBAIC0x OTMsMjUgKzE4MCwxOCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZXh0cmFxX2FkZF9zb3J0X3VwZGF0 DQogICAgICAgICBjdXJpbmYtPnNjb3JlW2ldIC09IHN1YjsNCiAgICAgICAgIGlmICggRURPTV9J TkZPKGQpLT5zY29yZVtpXSA8IGN1cmluZi0+c2NvcmVbaV0gKQ0KICAgICAgICAgICAgIGJyZWFr Ow0KLSAgICAgICAgUFJJTlQoNCwiXHRiZWhpbmQgZG9tYWluICVpLiVpIChzY29yZT0gJWkpXG4i LA0KLSAgICAgICAgICAgICAgY3VyaW5mLT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwNCi0gICAg ICAgICAgICAgIGN1cmluZi0+dmNwdS0+dmNwdV9pZCwgY3VyaW5mLT5zY29yZVtpXSk7DQogICAg IH0NCiANCi0gICAgLyogY3VyIG5vdyBjb250YWlucyB0aGUgZWxlbWVudCwgYmVmb3JlIHdoaWNo IHdlJ2xsIGVucXVldWUuICovDQotICAgIFBSSU5UKDMsICJcdGxpc3RfYWRkIHRvICVwXG4iLCBj dXItPnByZXYpOw0KKyAgICAvKiBjdXIgbm93IGNvbnRhaW5zIHRoZSBlbGVtZW50LCBiZWZvcmUg d2hpY2ggd2UnbGwgZW5xdWV1ZSAqLw0KICAgICBsaXN0X2FkZChFWFRSQUxJU1QoZCxpKSxjdXIt PnByZXYpOw0KICANCi0gICAgLyogQ29udGludWUgdXBkYXRpbmcgdGhlIGV4dHJhcS4gKi8NCisg ICAgLyogQ29udGludWUgdXBkYXRpbmcgdGhlIGV4dHJhcSAqLw0KICAgICBpZiAoIChjdXIgIT0g RVhUUkFRKGQtPnByb2Nlc3NvcixpKSkgJiYgc3ViICkNCiAgICAgew0KICAgICAgICAgZm9yICgg Y3VyID0gY3VyLT5uZXh0OyBjdXIgIT0gRVhUUkFRKGQtPnByb2Nlc3NvcixpKTsgY3VyID0gY3Vy LT5uZXh0ICkNCiAgICAgICAgIHsNCiAgICAgICAgICAgICBjdXJpbmYgPSBsaXN0X2VudHJ5KGN1 cixzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8sIGV4dHJhbGlzdFtpXSk7DQogICAgICAgICAgICAgY3Vy aW5mLT5zY29yZVtpXSAtPSBzdWI7DQotICAgICAgICAgICAgUFJJTlQoNCwgIlx0dXBkYXRpbmcg ZG9tYWluICVpLiVpIChzY29yZT0gJXUpXG4iLA0KLSAgICAgICAgICAgICAgICAgIGN1cmluZi0+ dmNwdS0+ZG9tYWluLT5kb21haW5faWQsIA0KLSAgICAgICAgICAgICAgICAgIGN1cmluZi0+dmNw dS0+dmNwdV9pZCwgY3VyaW5mLT5zY29yZVtpXSk7DQogICAgICAgICB9DQogICAgIH0NCiANCkBA IC0yMjEsMjkgKzIwMSwxNCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZXh0cmFxX2NoZWNrKHN0cnVj dCB2DQogew0KICAgICBpZiAoIGV4dHJhcV9vbihkLCBFWFRSQV9VVElMX1EpICkNCiAgICAgew0K LSAgICAgICAgUFJJTlQoMiwiRG9tICVpLiVpIGlzIG9uIEwxIGV4dHJhUVxuIiwNCi0gICAgICAg ICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBkLT52Y3B1X2lkKTsNCi0NCiAgICAgICAgIGlm ICggIShFRE9NX0lORk8oZCktPnN0YXR1cyAmIEVYVFJBX0FXQVJFKSAmJg0KICAgICAgICAgICAg ICAhZXh0cmFfcnVucyhFRE9NX0lORk8oZCkpICkNCi0gICAgICAgIHsNCiAgICAgICAgICAgICBl eHRyYXFfZGVsKGQsIEVYVFJBX1VUSUxfUSk7DQotICAgICAgICAgICAgUFJJTlQoMiwiUmVtb3Zl ZCBkb20gJWkuJWkgZnJvbSBMMSBleHRyYVFcbiIsDQotICAgICAgICAgICAgICAgICAgZC0+ZG9t YWluLT5kb21haW5faWQsIGQtPnZjcHVfaWQpOw0KLSAgICAgICAgfQ0KICAgICB9DQogICAgIGVs c2UNCiAgICAgew0KLSAgICAgICAgUFJJTlQoMiwgIkRvbSAlaS4laSBpcyBOT1Qgb24gTDEgZXh0 cmFRXG4iLA0KLSAgICAgICAgICAgICAgZC0+ZG9tYWluLT5kb21haW5faWQsDQotICAgICAgICAg ICAgICBkLT52Y3B1X2lkKTsNCi0NCiAgICAgICAgIGlmICggKEVET01fSU5GTyhkKS0+c3RhdHVz ICYgRVhUUkFfQVdBUkUpICYmIHNlZGZfcnVubmFibGUoZCkgKQ0KLSAgICAgICAgew0KICAgICAg ICAgICAgIGV4dHJhcV9hZGRfc29ydF91cGRhdGUoZCwgRVhUUkFfVVRJTF9RLCAwKTsNCi0gICAg ICAgICAgICBQUklOVCgyLCJBZGRlZCBkb20gJWkuJWkgdG8gTDEgZXh0cmFRXG4iLA0KLSAgICAg ICAgICAgICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBkLT52Y3B1X2lkKTsNCi0gICAgICAg IH0NCiAgICAgfQ0KIH0NCiANCkBAIC0yNTIsNyArMjE3LDcgQEAgc3RhdGljIGlubGluZSB2b2lk IGV4dHJhcV9jaGVja19hZGRfdW5ibA0KICAgICBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8gKmluZiA9 IEVET01fSU5GTyhkKTsNCiANCiAgICAgaWYgKCBpbmYtPnN0YXR1cyAmIEVYVFJBX0FXQVJFICkN Ci0gICAgICAgIC8qIFB1dCBvbiB0aGUgd2VpZ2h0ZWQgZXh0cmFxIHdpdGhvdXQgdXBkYXRpbmcg YW55IHNjb3Jlcy4gKi8NCisgICAgICAgIC8qIFB1dCBvbiB0aGUgd2VpZ2h0ZWQgZXh0cmFxIHdp dGhvdXQgdXBkYXRpbmcgYW55IHNjb3JlcyAqLw0KICAgICAgICAgZXh0cmFxX2FkZF9zb3J0X3Vw ZGF0ZShkLCBFWFRSQV9VVElMX1EsIDApOw0KIH0NCiANCkBAIC0yNjUsOCArMjMwLDYgQEAgc3Rh dGljIGlubGluZSB2b2lkIF9fZGVsX2Zyb21fcXVldWUoc3RydQ0KIHsNCiAgICAgc3RydWN0IGxp c3RfaGVhZCAqbGlzdCA9IExJU1QoZCk7DQogICAgIEFTU0VSVChfX3Rhc2tfb25fcXVldWUoZCkp Ow0KLSAgICBQUklOVCgzLCJSZW1vdmluZyBkb21haW4gJWkuJWkgKGJvcD0gJSJQUkl1NjQiKSBm cm9tIHJ1bnEvd2FpdHFcbiIsDQotICAgICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBkLT52 Y3B1X2lkLCBQRVJJT0RfQkVHSU4oRURPTV9JTkZPKGQpKSk7DQogICAgIGxpc3RfZGVsKGxpc3Qp Ow0KICAgICBsaXN0LT5uZXh0ID0gTlVMTDsNCiAgICAgQVNTRVJUKCFfX3Rhc2tfb25fcXVldWUo ZCkpOw0KQEAgLTI3OSwxMyArMjQyLDEyIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBsaXN0X2luc2Vy dF9zb3J0KA0KIHsNCiAgICAgc3RydWN0IGxpc3RfaGVhZCAgICAgKmN1cjsNCiANCi0gICAgLyog SXRlcmF0ZSB0aHJvdWdoIGFsbCBlbGVtZW50cyB0byBmaW5kIG91ciAiaG9sZSIuICovDQorICAg IC8qIEl0ZXJhdGUgdGhyb3VnaCBhbGwgZWxlbWVudHMgdG8gZmluZCBvdXIgImhvbGUiICovDQog ICAgIGxpc3RfZm9yX2VhY2goIGN1ciwgbGlzdCApDQogICAgICAgICBpZiAoIGNvbXAoZWxlbWVu dCwgY3VyKSA8IDAgKQ0KICAgICAgICAgICAgIGJyZWFrOw0KIA0KLSAgICAvKiBjdXIgbm93IGNv bnRhaW5zIHRoZSBlbGVtZW50LCBiZWZvcmUgd2hpY2ggd2UnbGwgZW5xdWV1ZS4gKi8NCi0gICAg UFJJTlQoMywiXHRsaXN0X2FkZCB0byAlcFxuIixjdXItPnByZXYpOw0KKyAgICAvKiBjdXIgbm93 IGNvbnRhaW5zIHRoZSBlbGVtZW50LCBiZWZvcmUgd2hpY2ggd2UnbGwgZW5xdWV1ZSAqLw0KICAg ICBsaXN0X2FkZChlbGVtZW50LCBjdXItPnByZXYpOw0KIH0NCiANCkBAIC0zMDMsMzAgKzI2NSwy OCBAQCBzdGF0aWMgaW50IG5hbWUjI19jb21wKHN0cnVjdCBsaXN0X2hlYWQqDQogICAgICAgICBy ZXR1cm4gMTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgXA0KIH0NCiANCi0vKiBhZGRzIGEgZG9tYWluIHRvIHRoZSBxdWV1ZSBvZiBwcm9jZXNz ZXMgd2hpY2ggd2FpdCBmb3IgdGhlIGJlZ2lubmluZyBvZiB0aGUNCi0gICBuZXh0IHBlcmlvZDsg dGhpcyBsaXN0IGlzIHRoZXJlZm9yZSBzb3J0ZXQgYnkgdGhpcyB0aW1lLCB3aGljaCBpcyBzaW1w bHkNCi0gICBhYnNvbC4gZGVhZGxpbmUgLSBwZXJpb2QNCisvKg0KKyAqIEFkZHMgYSBkb21haW4g dG8gdGhlIHF1ZXVlIG9mIHByb2Nlc3NlcyB3aGljaCB3YWl0IGZvciB0aGUgYmVnaW5uaW5nIG9m IHRoZQ0KKyAqIG5leHQgcGVyaW9kOyB0aGlzIGxpc3QgaXMgdGhlcmVmb3JlIHNvcnRldCBieSB0 aGlzIHRpbWUsIHdoaWNoIGlzIHNpbXBseQ0KKyAqIGFic29sLiBkZWFkbGluZSAtIHBlcmlvZC4N CiAgKi8gDQogRE9NQUlOX0NPTVBBUkVSKHdhaXRxLCBsaXN0LCBQRVJJT0RfQkVHSU4oZDEpLCBQ RVJJT0RfQkVHSU4oZDIpKTsNCiBzdGF0aWMgaW5saW5lIHZvaWQgX19hZGRfdG9fd2FpdHF1ZXVl X3NvcnQoc3RydWN0IHZjcHUgKnYpDQogew0KICAgICBBU1NFUlQoIV9fdGFza19vbl9xdWV1ZSh2 KSk7DQotICAgIFBSSU5UKDMsIkFkZGluZyBkb21haW4gJWkuJWkgKGJvcD0gJSJQUkl1NjQiKSB0 byB3YWl0cVxuIiwNCi0gICAgICAgICAgdi0+ZG9tYWluLT5kb21haW5faWQsIHYtPnZjcHVfaWQs IFBFUklPRF9CRUdJTihFRE9NX0lORk8odikpKTsNCiAgICAgbGlzdF9pbnNlcnRfc29ydChXQUlU USh2LT5wcm9jZXNzb3IpLCBMSVNUKHYpLCB3YWl0cV9jb21wKTsNCiAgICAgQVNTRVJUKF9fdGFz a19vbl9xdWV1ZSh2KSk7DQogfQ0KIA0KLS8qIGFkZHMgYSBkb21haW4gdG8gdGhlIHF1ZXVlIG9m IHByb2Nlc3NlcyB3aGljaCBoYXZlIHN0YXJ0ZWQgdGhlaXIgY3VycmVudA0KLSAgIHBlcmlvZCBh bmQgYXJlIHJ1bm5hYmxlIChpLmUuIG5vdCBibG9ja2VkLCBkaWVpbmcsLi4uKS4gVGhlIGZpcnN0 IGVsZW1lbnQNCi0gICBvbiB0aGlzIGxpc3QgaXMgcnVubmluZyBvbiB0aGUgcHJvY2Vzc29yLCBp ZiB0aGUgbGlzdCBpcyBlbXB0eSB0aGUgaWRsZQ0KLSAgIHRhc2sgd2lsbCBydW4uIEFzIHdlIGFy ZSBpbXBsZW1lbnRpbmcgRURGLCB0aGlzIGxpc3QgaXMgc29ydGVkIGJ5IGRlYWRsaW5lcy4NCisv Kg0KKyAqIEFkZHMgYSBkb21haW4gdG8gdGhlIHF1ZXVlIG9mIHByb2Nlc3NlcyB3aGljaCBoYXZl IHN0YXJ0ZWQgdGhlaXIgY3VycmVudA0KKyAqIHBlcmlvZCBhbmQgYXJlIHJ1bm5hYmxlIChpLmUu IG5vdCBibG9ja2VkLCBkaWVpbmcsLi4uKS4gVGhlIGZpcnN0IGVsZW1lbnQNCisgKiBvbiB0aGlz IGxpc3QgaXMgcnVubmluZyBvbiB0aGUgcHJvY2Vzc29yLCBpZiB0aGUgbGlzdCBpcyBlbXB0eSB0 aGUgaWRsZQ0KKyAqIHRhc2sgd2lsbCBydW4uIEFzIHdlIGFyZSBpbXBsZW1lbnRpbmcgRURGLCB0 aGlzIGxpc3QgaXMgc29ydGVkIGJ5IGRlYWRsaW5lcy4NCiAgKi8gDQogRE9NQUlOX0NPTVBBUkVS KHJ1bnEsIGxpc3QsIGQxLT5kZWFkbF9hYnMsIGQyLT5kZWFkbF9hYnMpOw0KIHN0YXRpYyBpbmxp bmUgdm9pZCBfX2FkZF90b19ydW5xdWV1ZV9zb3J0KHN0cnVjdCB2Y3B1ICp2KQ0KIHsNCi0gICAg UFJJTlQoMywiQWRkaW5nIGRvbWFpbiAlaS4laSAoZGVhZGw9ICUiUFJJdTY0IikgdG8gcnVucVxu IiwNCi0gICAgICAgICAgdi0+ZG9tYWluLT5kb21haW5faWQsIHYtPnZjcHVfaWQsIEVET01fSU5G Tyh2KS0+ZGVhZGxfYWJzKTsNCiAgICAgbGlzdF9pbnNlcnRfc29ydChSVU5RKHYtPnByb2Nlc3Nv ciksIExJU1QodiksIHJ1bnFfY29tcCk7DQogfQ0KIA0KQEAgLTQ1MywxMCArNDEzLDEwIEBAIHN0 YXRpYyB2b2lkIGRlc2NoZWRfZWRmX2RvbShzX3RpbWVfdCBub3cNCiB7DQogICAgIHN0cnVjdCBz ZWRmX3ZjcHVfaW5mbyogaW5mID0gRURPTV9JTkZPKGQpOw0KIA0KLSAgICAvKiBDdXJyZW50IGRv bWFpbiBpcyBydW5uaW5nIGluIHJlYWwgdGltZSBtb2RlLiAqLw0KKyAgICAvKiBDdXJyZW50IGRv bWFpbiBpcyBydW5uaW5nIGluIHJlYWwgdGltZSBtb2RlICovDQogICAgIEFTU0VSVChfX3Rhc2tf b25fcXVldWUoZCkpOw0KIA0KLSAgICAvKiBVcGRhdGUgdGhlIGRvbWFpbidzIGNwdXRpbWUuICov DQorICAgIC8qIFVwZGF0ZSB0aGUgZG9tYWluJ3MgY3B1dGltZSAqLw0KICAgICBpbmYtPmNwdXRp bWUgKz0gbm93IC0gaW5mLT5zY2hlZF9zdGFydF9hYnM7DQogDQogICAgIC8qDQpAQCAtNDY3LDcg KzQyNyw3IEBAIHN0YXRpYyB2b2lkIGRlc2NoZWRfZWRmX2RvbShzX3RpbWVfdCBub3cNCiAgICAg ICAgIHJldHVybjsNCiAgIA0KICAgICBfX2RlbF9mcm9tX3F1ZXVlKGQpOw0KLSAgDQorDQogICAg IC8qDQogICAgICAqIE1hbmFnZSBib29ra2VlcGluZyAoaS5lLiBjYWxjdWxhdGUgbmV4dCBkZWFk bGluZSwgbWVtb3Jpc2UNCiAgICAgICogb3ZlcnJ1bi10aW1lIG9mIHNsaWNlKSBvZiBmaW5pc2hl ZCBkb21haW5zLg0KQEAgLTQ3OCwzMCArNDM4LDMwIEBAIHN0YXRpYyB2b2lkIGRlc2NoZWRfZWRm X2RvbShzX3RpbWVfdCBub3cNCiAgIA0KICAgICAgICAgaWYgKCBpbmYtPnBlcmlvZCA8IGluZi0+ cGVyaW9kX29yaWcgKQ0KICAgICAgICAgew0KLSAgICAgICAgICAgIC8qIFRoaXMgZG9tYWluIHJ1 bnMgaW4gbGF0ZW5jeSBzY2FsaW5nIG9yIGJ1cnN0IG1vZGUuICovDQorICAgICAgICAgICAgLyog VGhpcyBkb21haW4gcnVucyBpbiBsYXRlbmN5IHNjYWxpbmcgb3IgYnVyc3QgbW9kZSAqLw0KICAg ICAgICAgICAgIGluZi0+cGVyaW9kICo9IDI7DQogICAgICAgICAgICAgaW5mLT5zbGljZSAgKj0g MjsNCiAgICAgICAgICAgICBpZiAoIChpbmYtPnBlcmlvZCA+IGluZi0+cGVyaW9kX29yaWcpIHx8 DQogICAgICAgICAgICAgICAgICAoaW5mLT5zbGljZSA+IGluZi0+c2xpY2Vfb3JpZykgKQ0KICAg ICAgICAgICAgIHsNCi0gICAgICAgICAgICAgICAgLyogUmVzZXQgc2xpY2UgYW5kIHBlcmlvZC4g Ki8NCisgICAgICAgICAgICAgICAgLyogUmVzZXQgc2xpY2UgYW5kIHBlcmlvZCAqLw0KICAgICAg ICAgICAgICAgICBpbmYtPnBlcmlvZCA9IGluZi0+cGVyaW9kX29yaWc7DQogICAgICAgICAgICAg ICAgIGluZi0+c2xpY2UgPSBpbmYtPnNsaWNlX29yaWc7DQogICAgICAgICAgICAgfQ0KICAgICAg ICAgfQ0KIA0KLSAgICAgICAgLyogU2V0IG5leHQgZGVhZGxpbmUuICovDQorICAgICAgICAvKiBT ZXQgbmV4dCBkZWFkbGluZSAqLw0KICAgICAgICAgaW5mLT5kZWFkbF9hYnMgKz0gaW5mLT5wZXJp b2Q7DQogICAgIH0NCiAgDQotICAgIC8qIEFkZCBhIHJ1bm5hYmxlIGRvbWFpbiB0byB0aGUgd2Fp dHF1ZXVlLiAqLw0KKyAgICAvKiBBZGQgYSBydW5uYWJsZSBkb21haW4gdG8gdGhlIHdhaXRxdWV1 ZSAqLw0KICAgICBpZiAoIHNlZGZfcnVubmFibGUoZCkgKQ0KICAgICB7DQogICAgICAgICBfX2Fk ZF90b193YWl0cXVldWVfc29ydChkKTsNCiAgICAgfQ0KICAgICBlbHNlDQogICAgIHsNCi0gICAg ICAgIC8qIFdlIGhhdmUgYSBibG9ja2VkIHJlYWx0aW1lIHRhc2sgLT4gcmVtb3ZlIGl0IGZyb20g ZXhxcyB0b28uICovDQorICAgICAgICAvKiBXZSBoYXZlIGEgYmxvY2tlZCByZWFsdGltZSB0YXNr IC0+IHJlbW92ZSBpdCBmcm9tIGV4cXMgdG9vICovDQogICAgICAgICBpZiAoIGV4dHJhcV9vbihk LCBFWFRSQV9QRU5fUSkgKQ0KICAgICAgICAgICAgIGV4dHJhcV9kZWwoZCwgRVhUUkFfUEVOX1Ep Ow0KICAgICAgICAgaWYgKCBleHRyYXFfb24oZCwgRVhUUkFfVVRJTF9RKSApDQpAQCAtNTIxLDgg KzQ4MSw2IEBAIHN0YXRpYyB2b2lkIHVwZGF0ZV9xdWV1ZXMoDQogICAgIHN0cnVjdCBsaXN0X2hl YWQgICAgICpjdXIsICp0bXA7DQogICAgIHN0cnVjdCBzZWRmX3ZjcHVfaW5mbyAqY3VyaW5mOw0K ICANCi0gICAgUFJJTlQoMywiVXBkYXRpbmcgd2FpdHEuLlxuIik7DQotDQogICAgIC8qDQogICAg ICAqIENoZWNrIGZvciB0aGUgZmlyc3QgZWxlbWVudHMgb2YgdGhlIHdhaXRxdWV1ZSwgd2hldGhl ciB0aGVpcg0KICAgICAgKiBuZXh0IHBlcmlvZCBoYXMgYWxyZWFkeSBzdGFydGVkLg0KQEAgLTUz MCw0MSArNDg4LDMyIEBAIHN0YXRpYyB2b2lkIHVwZGF0ZV9xdWV1ZXMoDQogICAgIGxpc3RfZm9y X2VhY2hfc2FmZSAoIGN1ciwgdG1wLCB3YWl0cSApDQogICAgIHsNCiAgICAgICAgIGN1cmluZiA9 IGxpc3RfZW50cnkoY3VyLCBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8sIGxpc3QpOw0KLSAgICAgICAg UFJJTlQoNCwiXHRMb29raW5nIEAgZG9tICVpLiVpXG4iLA0KLSAgICAgICAgICAgICAgY3VyaW5m LT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwgY3VyaW5mLT52Y3B1LT52Y3B1X2lkKTsNCiAgICAg ICAgIGlmICggUEVSSU9EX0JFR0lOKGN1cmluZikgPiBub3cgKQ0KICAgICAgICAgICAgIGJyZWFr Ow0KICAgICAgICAgX19kZWxfZnJvbV9xdWV1ZShjdXJpbmYtPnZjcHUpOw0KICAgICAgICAgX19h ZGRfdG9fcnVucXVldWVfc29ydChjdXJpbmYtPnZjcHUpOw0KICAgICB9DQogIA0KLSAgICBQUklO VCgzLCJVcGRhdGluZyBydW5xLi5cbiIpOw0KLQ0KLSAgICAvKiBQcm9jZXNzIHRoZSBydW5xLCBm aW5kIGRvbWFpbnMgdGhhdCBhcmUgb24gdGhlIHJ1bnEgdGhhdCBzaG91bGRuJ3QuICovDQorICAg IC8qIFByb2Nlc3MgdGhlIHJ1bnEsIGZpbmQgZG9tYWlucyB0aGF0IGFyZSBvbiB0aGUgcnVucSB0 aGF0IHNob3VsZG4ndCAqLw0KICAgICBsaXN0X2Zvcl9lYWNoX3NhZmUgKCBjdXIsIHRtcCwgcnVu cSApDQogICAgIHsNCiAgICAgICAgIGN1cmluZiA9IGxpc3RfZW50cnkoY3VyLHN0cnVjdCBzZWRm X3ZjcHVfaW5mbyxsaXN0KTsNCi0gICAgICAgIFBSSU5UKDQsIlx0TG9va2luZyBAIGRvbSAlaS4l aVxuIiwNCi0gICAgICAgICAgICAgIGN1cmluZi0+dmNwdS0+ZG9tYWluLT5kb21haW5faWQsIGN1 cmluZi0+dmNwdS0+dmNwdV9pZCk7DQogDQogICAgICAgICBpZiAoIHVubGlrZWx5KGN1cmluZi0+ c2xpY2UgPT0gMCkgKQ0KICAgICAgICAgew0KLSAgICAgICAgICAgIC8qIElnbm9yZSBkb21haW5z IHdpdGggZW1wdHkgc2xpY2UuICovDQotICAgICAgICAgICAgUFJJTlQoNCwiXHRVcGRhdGluZyB6 ZXJvLXNsaWNlIGRvbWFpbiAlaS4laVxuIiwNCi0gICAgICAgICAgICAgICAgICBjdXJpbmYtPnZj cHUtPmRvbWFpbi0+ZG9tYWluX2lkLA0KLSAgICAgICAgICAgICAgICAgIGN1cmluZi0+dmNwdS0+ dmNwdV9pZCk7DQorICAgICAgICAgICAgLyogSWdub3JlIGRvbWFpbnMgd2l0aCBlbXB0eSBzbGlj ZSAqLw0KICAgICAgICAgICAgIF9fZGVsX2Zyb21fcXVldWUoY3VyaW5mLT52Y3B1KTsNCiANCi0g ICAgICAgICAgICAvKiBNb3ZlIHRoZW0gdG8gdGhlaXIgbmV4dCBwZXJpb2QuICovDQorICAgICAg ICAgICAgLyogTW92ZSB0aGVtIHRvIHRoZWlyIG5leHQgcGVyaW9kICovDQogICAgICAgICAgICAg Y3VyaW5mLT5kZWFkbF9hYnMgKz0gY3VyaW5mLT5wZXJpb2Q7DQogDQotICAgICAgICAgICAgLyog RW5zdXJlIHRoYXQgdGhlIHN0YXJ0IG9mIHRoZSBuZXh0IHBlcmlvZCBpcyBpbiB0aGUgZnV0dXJl LiAqLw0KKyAgICAgICAgICAgIC8qIEVuc3VyZSB0aGF0IHRoZSBzdGFydCBvZiB0aGUgbmV4dCBw ZXJpb2QgaXMgaW4gdGhlIGZ1dHVyZSAqLw0KICAgICAgICAgICAgIGlmICggdW5saWtlbHkoUEVS SU9EX0JFR0lOKGN1cmluZikgPCBub3cpICkNCiAgICAgICAgICAgICAgICAgY3VyaW5mLT5kZWFk bF9hYnMgKz0gDQogICAgICAgICAgICAgICAgICAgICAoRElWX1VQKG5vdyAtIFBFUklPRF9CRUdJ TihjdXJpbmYpLA0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjdXJpbmYtPnBlcmlvZCkp ICogY3VyaW5mLT5wZXJpb2Q7DQogDQotICAgICAgICAgICAgLyogUHV0IHRoZW0gYmFjayBpbnRv IHRoZSBxdWV1ZS4gKi8NCisgICAgICAgICAgICAvKiBQdXQgdGhlbSBiYWNrIGludG8gdGhlIHF1 ZXVlICovDQogICAgICAgICAgICAgX19hZGRfdG9fd2FpdHF1ZXVlX3NvcnQoY3VyaW5mLT52Y3B1 KTsNCiAgICAgICAgIH0NCiAgICAgICAgIGVsc2UgaWYgKCB1bmxpa2VseSgoY3VyaW5mLT5kZWFk bF9hYnMgPCBub3cpIHx8DQpAQCAtNTc0LDE4ICs1MjMsMTggQEAgc3RhdGljIHZvaWQgdXBkYXRl X3F1ZXVlcygNCiAgICAgICAgICAgICAgKiBXZSBtaXNzZWQgdGhlIGRlYWRsaW5lIG9yIHRoZSBz bGljZSB3YXMgYWxyZWFkeSBmaW5pc2hlZC4NCiAgICAgICAgICAgICAgKiBNaWdodCBoYXBlbiBi ZWNhdXNlIG9mIGRvbV9hZGouDQogICAgICAgICAgICAgICovDQotICAgICAgICAgICAgUFJJTlQo NCwiXHREb21haW4gJWkuJWkgZXhjZWVkZWQgaXQncyBkZWFkbGluZS8iDQotICAgICAgICAgICAg ICAgICAgInNsaWNlICglIlBSSXU2NCIgLyAlIlBSSXU2NCIpIG5vdzogJSJQUkl1NjQNCi0gICAg ICAgICAgICAgICAgICAiIGNwdXRpbWU6ICUiUFJJdTY0IlxuIiwNCi0gICAgICAgICAgICAgICAg ICBjdXJpbmYtPnZjcHUtPmRvbWFpbi0+ZG9tYWluX2lkLA0KLSAgICAgICAgICAgICAgICAgIGN1 cmluZi0+dmNwdS0+dmNwdV9pZCwNCi0gICAgICAgICAgICAgICAgICBjdXJpbmYtPmRlYWRsX2Fi cywgY3VyaW5mLT5zbGljZSwgbm93LA0KLSAgICAgICAgICAgICAgICAgIGN1cmluZi0+Y3B1dGlt ZSk7DQorICAgICAgICAgICAgcHJpbnRrKCJcdERvbWFpbiAlaS4laSBleGNlZWRlZCBpdCdzIGRl YWRsaW5lLyINCisgICAgICAgICAgICAgICAgICAgInNsaWNlICglIlBSSXU2NCIgLyAlIlBSSXU2 NCIpIG5vdzogJSJQUkl1NjQNCisgICAgICAgICAgICAgICAgICAgIiBjcHV0aW1lOiAlIlBSSXU2 NCJcbiIsDQorICAgICAgICAgICAgICAgICAgIGN1cmluZi0+dmNwdS0+ZG9tYWluLT5kb21haW5f aWQsDQorICAgICAgICAgICAgICAgICAgIGN1cmluZi0+dmNwdS0+dmNwdV9pZCwNCisgICAgICAg ICAgICAgICAgICAgY3VyaW5mLT5kZWFkbF9hYnMsIGN1cmluZi0+c2xpY2UsIG5vdywNCisgICAg ICAgICAgICAgICAgICAgY3VyaW5mLT5jcHV0aW1lKTsNCiAgICAgICAgICAgICBfX2RlbF9mcm9t X3F1ZXVlKGN1cmluZi0+dmNwdSk7DQogDQotICAgICAgICAgICAgLyogQ29tbW9uIGNhc2U6IHdl IG1pc3Mgb25lIHBlcmlvZC4gKi8NCisgICAgICAgICAgICAvKiBDb21tb24gY2FzZTogd2UgbWlz cyBvbmUgcGVyaW9kICovDQogICAgICAgICAgICAgY3VyaW5mLT5kZWFkbF9hYnMgKz0gY3VyaW5m LT5wZXJpb2Q7DQotICAgDQorDQogICAgICAgICAgICAgLyoNCiAgICAgICAgICAgICAgKiBJZiB3 ZSBhcmUgc3RpbGwgYmVoaW5kOiBtb2R1bG8gYXJpdGhtZXRpYywgZm9yY2UgZGVhZGxpbmUNCiAg ICAgICAgICAgICAgKiB0byBiZSBpbiBmdXR1cmUgYW5kIGFsaWduZWQgdG8gcGVyaW9kIGJvcmRl cnMuDQpAQCAtNTk2LDcgKzU0NSw3IEBAIHN0YXRpYyB2b2lkIHVwZGF0ZV9xdWV1ZXMoDQogICAg ICAgICAgICAgICAgICAgICAgICAgICAgY3VyaW5mLT5wZXJpb2QpICogY3VyaW5mLT5wZXJpb2Q7 DQogICAgICAgICAgICAgQVNTRVJUKGN1cmluZi0+ZGVhZGxfYWJzID49IG5vdyk7DQogDQotICAg ICAgICAgICAgLyogR2l2ZSBhIGZyZXNoIHNsaWNlLiAqLw0KKyAgICAgICAgICAgIC8qIEdpdmUg YSBmcmVzaCBzbGljZSAqLw0KICAgICAgICAgICAgIGN1cmluZi0+Y3B1dGltZSA9IDA7DQogICAg ICAgICAgICAgaWYgKCBQRVJJT0RfQkVHSU4oY3VyaW5mKSA+IG5vdyApDQogICAgICAgICAgICAg ICAgIF9fYWRkX3RvX3dhaXRxdWV1ZV9zb3J0KGN1cmluZi0+dmNwdSk7DQpAQCAtNjA2LDE3ICs1 NTUsMTcgQEAgc3RhdGljIHZvaWQgdXBkYXRlX3F1ZXVlcygNCiAgICAgICAgIGVsc2UNCiAgICAg ICAgICAgICBicmVhazsNCiAgICAgfQ0KLQ0KLSAgICBQUklOVCgzLCJkb25lIHVwZGF0aW5nIHRo ZSBxdWV1ZXNcbiIpOw0KIH0NCiANCiANCi0vKiByZW1vdmVzIGEgZG9tYWluIGZyb20gdGhlIGhl YWQgb2YgdGhlIGFjY29yZGluZyBleHRyYVEgYW5kDQotICAgcmVxdWV1ZXMgaXQgYXQgYSBzcGVj aWZpZWQgcG9zaXRpb246DQotICAgICByb3VuZC1yb2JpbiBleHRyYXRpbWU6IGVuZCBvZiBleHRy YVENCi0gICAgIHdlaWdodGVkIGV4dC46IGluc2VydCBpbiBzb3J0ZWQgbGlzdCBieSBzY29yZQ0K LSAgIGlmIHRoZSBkb21haW4gaXMgYmxvY2tlZCAvIGhhcyByZWdhaW5lZCBpdHMgc2hvcnQtYmxv Y2stbG9zcw0KLSAgIHRpbWUgaXQgaXMgbm90IHB1dCBvbiBhbnkgcXVldWUgKi8NCisvKg0KKyAq IHJlbW92ZXMgYSBkb21haW4gZnJvbSB0aGUgaGVhZCBvZiB0aGUgYWNjb3JkaW5nIGV4dHJhUSBh bmQNCisgKiByZXF1ZXVlcyBpdCBhdCBhIHNwZWNpZmllZCBwb3NpdGlvbjoNCisgKiAgIHJvdW5k LXJvYmluIGV4dHJhdGltZTogZW5kIG9mIGV4dHJhUQ0KKyAqICAgd2VpZ2h0ZWQgZXh0LjogaW5z ZXJ0IGluIHNvcnRlZCBsaXN0IGJ5IHNjb3JlDQorICogaWYgdGhlIGRvbWFpbiBpcyBibG9ja2Vk IC8gaGFzIHJlZ2FpbmVkIGl0cyBzaG9ydC1ibG9jay1sb3NzDQorICogdGltZSBpdCBpcyBub3Qg cHV0IG9uIGFueSBxdWV1ZS4NCisgKi8NCiBzdGF0aWMgdm9pZCBkZXNjaGVkX2V4dHJhX2RvbShz X3RpbWVfdCBub3csIHN0cnVjdCB2Y3B1ICpkKQ0KIHsNCiAgICAgc3RydWN0IHNlZGZfdmNwdV9p bmZvICppbmYgPSBFRE9NX0lORk8oZCk7DQpAQCAtNjI1LDI5ICs1NzQsMjUgQEAgc3RhdGljIHZv aWQgZGVzY2hlZF9leHRyYV9kb20oc190aW1lX3Qgbg0KIA0KICAgICBBU1NFUlQoZXh0cmFxX29u KGQsIGkpKTsNCiANCi0gICAgLyogVW5zZXQgYWxsIHJ1bm5pbmcgZmxhZ3MuICovDQorICAgIC8q IFVuc2V0IGFsbCBydW5uaW5nIGZsYWdzICovDQogICAgIGluZi0+c3RhdHVzICAmPSB+KEVYVFJB X1JVTl9QRU4gfCBFWFRSQV9SVU5fVVRJTCk7DQotICAgIC8qIEZyZXNoIHNsaWNlIGZvciB0aGUg bmV4dCBydW4uICovDQorICAgIC8qIEZyZXNoIHNsaWNlIGZvciB0aGUgbmV4dCBydW4gKi8NCiAg ICAgaW5mLT5jcHV0aW1lID0gMDsNCi0gICAgLyogQWNjdW11bGF0ZSB0b3RhbCBleHRyYXRpbWUu ICovDQorICAgIC8qIEFjY3VtdWxhdGUgdG90YWwgZXh0cmF0aW1lICovDQogICAgIGluZi0+ZXh0 cmFfdGltZV90b3QgKz0gbm93IC0gaW5mLT5zY2hlZF9zdGFydF9hYnM7DQogICAgIC8qIFJlbW92 ZSBleHRyYWRvbWFpbiBmcm9tIGhlYWQgb2YgdGhlIHF1ZXVlLiAqLw0KICAgICBleHRyYXFfZGVs KGQsIGkpOw0KIA0KLSAgICAvKiBVcGRhdGUgdGhlIHNjb3JlLiAqLw0KKyAgICAvKiBVcGRhdGUg dGhlIHNjb3JlICovDQogICAgIG9sZHNjb3JlID0gaW5mLT5zY29yZVtpXTsNCiAgICAgaWYgKCBp ID09IEVYVFJBX1BFTl9RICkNCiAgICAgew0KLSAgICAgICAgLypkb21haW4gd2FzIHJ1bm5pbmcg aW4gTDAgZXh0cmFxKi8NCi0gICAgICAgIC8qcmVkdWNlIGJsb2NrIGxvc3QsIHByb2JhYmx5IG1v cmUgc29waGlzdGljYXRpb24gaGVyZSEqLw0KKyAgICAgICAgLyogRG9tYWluIHdhcyBydW5uaW5n IGluIEwwIGV4dHJhcSAqLw0KKyAgICAgICAgLyogcmVkdWNlIGJsb2NrIGxvc3QsIHByb2JhYmx5 IG1vcmUgc29waGlzdGljYXRpb24gaGVyZSEqLw0KICAgICAgICAgLyppbmYtPnNob3J0X2Jsb2Nr X2xvc3RfdG90IC09IEVYVFJBX1FVQU5UVU07Ki8NCiAgICAgICAgIGluZi0+c2hvcnRfYmxvY2tf bG9zdF90b3QgLT0gbm93IC0gaW5mLT5zY2hlZF9zdGFydF9hYnM7DQotICAgICAgICBQUklOVCgz LCJEb21haW4gJWkuJWk6IFNob3J0X2Jsb2NrX2xvc3M6ICUiUFJJaTY0IlxuIiwgDQotICAgICAg ICAgICAgICBpbmYtPnZjcHUtPmRvbWFpbi0+ZG9tYWluX2lkLCBpbmYtPnZjcHUtPnZjcHVfaWQs DQotICAgICAgICAgICAgICBpbmYtPnNob3J0X2Jsb2NrX2xvc3RfdG90KTsNCiAjaWYgMA0KLSAg ICAgICAgLyoNCi0gICAgICAgICAqIEtBRjogSWYgd2UgZG9uJ3QgZXhpdCBzaG9ydC1ibG9ja2lu ZyBzdGF0ZSBhdCB0aGlzIHBvaW50DQorICAgICAgICAvKiBLQUY6IElmIHdlIGRvbid0IGV4aXQg c2hvcnQtYmxvY2tpbmcgc3RhdGUgYXQgdGhpcyBwb2ludA0KICAgICAgICAgICogZG9tYWluMCBj YW4gc3RlYWwgYWxsIENQVSBmb3IgdXAgdG8gMTAgc2Vjb25kcyBiZWZvcmUNCiAgICAgICAgICAq IHNjaGVkdWxpbmcgc2V0dGxlcyBkb3duICh3aGVuIGNvbXBldGluZyBhZ2FpbnN0IGFub3RoZXIN CiAgICAgICAgICAqIENQVS1ib3VuZCBkb21haW4pLiBEb2luZyB0aGlzIHNlZW1zIHRvIG1ha2Ug dGhpbmdzIGJlaGF2ZQ0KQEAgLTY1Niw1MSArNjAxLDU5IEBAIHN0YXRpYyB2b2lkIGRlc2NoZWRf ZXh0cmFfZG9tKHNfdGltZV90IG4NCiAgICAgICAgIGlmICggaW5mLT5zaG9ydF9ibG9ja19sb3N0 X3RvdCA8PSAwICkNCiAjZW5kaWYNCiAgICAgICAgIHsNCi0gICAgICAgICAgICBQUklOVCg0LCJE b21haW4gJWkuJWkgY29tcGVuc2F0ZWQgc2hvcnQgYmxvY2sgbG9zcyFcbiIsDQotICAgICAgICAg ICAgICAgICAgaW5mLT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwgaW5mLT52Y3B1LT52Y3B1X2lk KTsNCi0gICAgICAgICAgICAvKndlIGhhdmUgKG92ZXItKWNvbXBlbnNhdGVkIG91ciBibG9jayBw ZW5hbHR5Ki8NCisgICAgICAgICAgICAvKiBXZSBoYXZlIChvdmVyLSljb21wZW5zYXRlZCBvdXIg YmxvY2sgcGVuYWx0eSAqLw0KICAgICAgICAgICAgIGluZi0+c2hvcnRfYmxvY2tfbG9zdF90b3Qg PSAwOw0KLSAgICAgICAgICAgIC8qd2UgZG9uJ3Qgd2FudCBhIHBsYWNlIG9uIHRoZSBwZW5hbHR5 IHF1ZXVlIGFueW1vcmUhKi8NCisgICAgICAgICAgICAvKiBXZSBkb24ndCB3YW50IGEgcGxhY2Ug b24gdGhlIHBlbmFsdHkgcXVldWUgYW55bW9yZSEgKi8NCiAgICAgICAgICAgICBpbmYtPnN0YXR1 cyAmPSB+RVhUUkFfV0FOVF9QRU5fUTsNCiAgICAgICAgICAgICBnb3RvIGNoZWNrX2V4dHJhX3F1 ZXVlczsNCiAgICAgICAgIH0NCiANCi0gICAgICAgIC8qd2UgaGF2ZSB0byBnbyBhZ2FpbiBmb3Ig YW5vdGhlciB0cnkgaW4gdGhlIGJsb2NrLWV4dHJhcSwNCi0gICAgICAgICAgdGhlIHNjb3JlIGlz IG5vdCB1c2VkIGluY3JlbWFudGFsbHkgaGVyZSwgYXMgdGhpcyBpcw0KLSAgICAgICAgICBhbHJl YWR5IGRvbmUgYnkgcmVjYWxjdWxhdGluZyB0aGUgYmxvY2tfbG9zdCovDQorICAgICAgICAvKg0K KyAgICAgICAgICogV2UgaGF2ZSB0byBnbyBhZ2FpbiBmb3IgYW5vdGhlciB0cnkgaW4gdGhlIGJs b2NrLWV4dHJhcSwNCisgICAgICAgICAqIHRoZSBzY29yZSBpcyBub3QgdXNlZCBpbmNyZW1hbnRh bGx5IGhlcmUsIGFzIHRoaXMgaXMNCisgICAgICAgICAqIGFscmVhZHkgZG9uZSBieSByZWNhbGN1 bGF0aW5nIHRoZSBibG9ja19sb3N0DQorICAgICAgICAgKi8NCiAgICAgICAgIGluZi0+c2NvcmVb RVhUUkFfUEVOX1FdID0gKGluZi0+cGVyaW9kIDw8IDEwKSAvDQogICAgICAgICAgICAgaW5mLT5z aG9ydF9ibG9ja19sb3N0X3RvdDsNCiAgICAgICAgIG9sZHNjb3JlID0gMDsNCiAgICAgfQ0KICAg ICBlbHNlDQogICAgIHsNCi0gICAgICAgIC8qZG9tYWluIHdhcyBydW5uaW5nIGluIEwxIGV4dHJh cSA9PiBzY29yZSBpcyBpbnZlcnNlIG9mDQotICAgICAgICAgIHV0aWxpemF0aW9uIGFuZCBpcyB1 c2VkIHNvbWV3aGF0IGluY3JlbWVudGFsISovDQorICAgICAgICAvKg0KKyAgICAgICAgICogRG9t YWluIHdhcyBydW5uaW5nIGluIEwxIGV4dHJhcSA9PiBzY29yZSBpcyBpbnZlcnNlIG9mDQorICAg ICAgICAgKiB1dGlsaXphdGlvbiBhbmQgaXMgdXNlZCBzb21ld2hhdCBpbmNyZW1lbnRhbCENCisg ICAgICAgICAqLw0KICAgICAgICAgaWYgKCAhaW5mLT5leHRyYXdlaWdodCApDQotICAgICAgICAg ICAgLypOQjogdXNlIGZpeGVkIHBvaW50IGFyaXRobWV0aWMgd2l0aCAxMCBiaXRzKi8NCisgICAg ICAgIHsNCisgICAgICAgICAgICAvKiBOQjogdXNlIGZpeGVkIHBvaW50IGFyaXRobWV0aWMgd2l0 aCAxMCBiaXRzICovDQogICAgICAgICAgICAgaW5mLT5zY29yZVtFWFRSQV9VVElMX1FdID0gKGlu Zi0+cGVyaW9kIDw8IDEwKSAvDQogICAgICAgICAgICAgICAgIGluZi0+c2xpY2U7DQorICAgICAg ICB9DQogICAgICAgICBlbHNlDQotICAgICAgICAgICAgLypjb252ZXJzaW9uIGJldHdlZW4gcmVh bHRpbWUgdXRpbGlzYXRpb24gYW5kIGV4dHJhd2llZ2h0Og0KLSAgICAgICAgICAgICAgZnVsbCAo aWUgMTAwJSkgdXRpbGl6YXRpb24gaXMgZXF1aXZhbGVudCB0byAxMjggZXh0cmF3ZWlnaHQqLw0K KyAgICAgICAgew0KKyAgICAgICAgICAgIC8qDQorICAgICAgICAgICAgICogQ29udmVyc2lvbiBi ZXR3ZWVuIHJlYWx0aW1lIHV0aWxpc2F0aW9uIGFuZCBleHRyYXdpZWdodDoNCisgICAgICAgICAg ICAgKiBmdWxsIChpZSAxMDAlKSB1dGlsaXphdGlvbiBpcyBlcXVpdmFsZW50IHRvIDEyOCBleHRy YXdlaWdodA0KKyAgICAgICAgICAgICAqLw0KICAgICAgICAgICAgIGluZi0+c2NvcmVbRVhUUkFf VVRJTF9RXSA9ICgxPDwxNykgLyBpbmYtPmV4dHJhd2VpZ2h0Ow0KKyAgICAgICAgfQ0KICAgICB9 DQogDQogIGNoZWNrX2V4dHJhX3F1ZXVlczoNCi0gICAgLyogQWRkaW5nIGEgcnVubmFibGUgZG9t YWluIHRvIHRoZSByaWdodCBxdWV1ZSBhbmQgcmVtb3ZpbmcgYmxvY2tlZCBvbmVzKi8NCisgICAg LyogQWRkaW5nIGEgcnVubmFibGUgZG9tYWluIHRvIHRoZSByaWdodCBxdWV1ZSBhbmQgcmVtb3Zp bmcgYmxvY2tlZCBvbmVzICovDQogICAgIGlmICggc2VkZl9ydW5uYWJsZShkKSApDQogICAgIHsN Ci0gICAgICAgIC8qYWRkIGFjY29yZGluZyB0byBzY29yZTogd2VpZ2h0ZWQgcm91bmQgcm9iaW4q Lw0KKyAgICAgICAgLyogQWRkIGFjY29yZGluZyB0byBzY29yZTogd2VpZ2h0ZWQgcm91bmQgcm9i aW4gKi8NCiAgICAgICAgIGlmICgoKGluZi0+c3RhdHVzICYgRVhUUkFfQVdBUkUpICYmIChpID09 IEVYVFJBX1VUSUxfUSkpIHx8DQogICAgICAgICAgICAgKChpbmYtPnN0YXR1cyAmIEVYVFJBX1dB TlRfUEVOX1EpICYmIChpID09IEVYVFJBX1BFTl9RKSkpDQogICAgICAgICAgICAgZXh0cmFxX2Fk ZF9zb3J0X3VwZGF0ZShkLCBpLCBvbGRzY29yZSk7DQogICAgIH0NCiAgICAgZWxzZQ0KICAgICB7 DQotICAgICAgICAvKnJlbW92ZSB0aGlzIGJsb2NrZWQgZG9tYWluIGZyb20gdGhlIHdhaXRxISov DQorICAgICAgICAvKiBSZW1vdmUgdGhpcyBibG9ja2VkIGRvbWFpbiBmcm9tIHRoZSB3YWl0cSEg Ki8NCiAgICAgICAgIF9fZGVsX2Zyb21fcXVldWUoZCk7DQotICAgICAgICAvKm1ha2Ugc3VyZSB0 aGF0IHdlIHJlbW92ZSBhIGJsb2NrZWQgZG9tYWluIGZyb20gdGhlIG90aGVyDQotICAgICAgICAg IGV4dHJhcSB0b28qLw0KKyAgICAgICAgLyogTWFrZSBzdXJlIHRoYXQgd2UgcmVtb3ZlIGEgYmxv Y2tlZCBkb21haW4gZnJvbSB0aGUgb3RoZXINCisgICAgICAgICAqIGV4dHJhcSB0b28uICovDQog ICAgICAgICBpZiAoIGkgPT0gRVhUUkFfUEVOX1EgKQ0KICAgICAgICAgew0KICAgICAgICAgICAg IGlmICggZXh0cmFxX29uKGQsIEVYVFJBX1VUSUxfUSkgKQ0KQEAgLTczMiw4ICs2ODUsMTAgQEAg c3RhdGljIHN0cnVjdCB0YXNrX3NsaWNlIHNlZGZfZG9fZXh0cmFfcw0KIA0KICAgICBpZiAoICFs aXN0X2VtcHR5KGV4dHJhcVtFWFRSQV9QRU5fUV0pICkNCiAgICAgew0KLSAgICAgICAgLyp3ZSBz dGlsbCBoYXZlIGVsZW1lbnRzIG9uIHRoZSBsZXZlbCAwIGV4dHJhcSANCi0gICAgICAgICAgPT4g bGV0IHRob3NlIHJ1biBmaXJzdCEqLw0KKyAgICAgICAgLyoNCisgICAgICAgICAqIFdlIHN0aWxs IGhhdmUgZWxlbWVudHMgb24gdGhlIGxldmVsIDAgZXh0cmFxDQorICAgICAgICAgKiA9PiBsZXQg dGhvc2UgcnVuIGZpcnN0IQ0KKyAgICAgICAgICovDQogICAgICAgICBydW5pbmYgICA9IGxpc3Rf ZW50cnkoZXh0cmFxW0VYVFJBX1BFTl9RXS0+bmV4dCwgDQogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgc3RydWN0IHNlZGZfdmNwdV9pbmZvLCBleHRyYWxpc3RbRVhUUkFfUEVOX1FdKTsN CiAgICAgICAgIHJ1bmluZi0+c3RhdHVzIHw9IEVYVFJBX1JVTl9QRU47DQpAQCAtNzQ3LDcgKzcw Miw3IEBAIHN0YXRpYyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX2V4dHJhX3MNCiAgICAgew0K ICAgICAgICAgaWYgKCAhbGlzdF9lbXB0eShleHRyYXFbRVhUUkFfVVRJTF9RXSkgKQ0KICAgICAg ICAgew0KLSAgICAgICAgICAgIC8qdXNlIGVsZW1lbnRzIGZyb20gdGhlIG5vcm1hbCBleHRyYXF1 ZXVlKi8NCisgICAgICAgICAgICAvKiBVc2UgZWxlbWVudHMgZnJvbSB0aGUgbm9ybWFsIGV4dHJh cXVldWUgKi8NCiAgICAgICAgICAgICBydW5pbmYgICA9IGxpc3RfZW50cnkoZXh0cmFxW0VYVFJB X1VUSUxfUV0tPm5leHQsDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVj dCBzZWRmX3ZjcHVfaW5mbywNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZXh0 cmFsaXN0W0VYVFJBX1VUSUxfUV0pOw0KQEAgLTc3MiwxMSArNzI3LDEzIEBAIHN0YXRpYyBzdHJ1 Y3QgdGFza19zbGljZSBzZWRmX2RvX2V4dHJhX3MNCiB9DQogDQogDQotLyogTWFpbiBzY2hlZHVs aW5nIGZ1bmN0aW9uDQotICAgUmVhc29ucyBmb3IgY2FsbGluZyB0aGlzIGZ1bmN0aW9uIGFyZToN Ci0gICAtdGltZXNsaWNlIGZvciB0aGUgY3VycmVudCBwZXJpb2QgdXNlZCB1cA0KLSAgIC1kb21h aW4gb24gd2FpdHF1ZXVlIGhhcyBzdGFydGVkIGl0J3MgcGVyaW9kDQotICAgLWFuZCB2YXJpb3Vz IG90aGVycyA7KSBpbiBnZW5lcmFsOiBkZXRlcm1pbmUgd2hpY2ggZG9tYWluIHRvIHJ1biBuZXh0 Ki8NCisvKg0KKyAqIE1haW4gc2NoZWR1bGluZyBmdW5jdGlvbg0KKyAqIFJlYXNvbnMgZm9yIGNh bGxpbmcgdGhpcyBmdW5jdGlvbiBhcmU6DQorICogLXRpbWVzbGljZSBmb3IgdGhlIGN1cnJlbnQg cGVyaW9kIHVzZWQgdXANCisgKiAtZG9tYWluIG9uIHdhaXRxdWV1ZSBoYXMgc3RhcnRlZCBpdCdz IHBlcmlvZA0KKyAqIC1hbmQgdmFyaW91cyBvdGhlcnMgOykgaW4gZ2VuZXJhbDogZGV0ZXJtaW5l IHdoaWNoIGRvbWFpbiB0byBydW4gbmV4dA0KKyAqLw0KIHN0YXRpYyBzdHJ1Y3QgdGFza19zbGlj ZSBzZWRmX2RvX3NjaGVkdWxlKA0KICAgICBjb25zdCBzdHJ1Y3Qgc2NoZWR1bGVyICpvcHMsIHNf dGltZV90IG5vdywgYm9vbF90IHRhc2tsZXRfd29ya19zY2hlZHVsZWQpDQogew0KQEAgLTc4OSwx MyArNzQ2LDE1IEBAIHN0YXRpYyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX3NjaGVkdWwNCiAg ICAgc3RydWN0IHNlZGZfdmNwdV9pbmZvICpydW5pbmYsICp3YWl0aW5mOw0KICAgICBzdHJ1Y3Qg dGFza19zbGljZSAgICAgIHJldDsNCiANCi0gICAgLyppZGxlIHRhc2tzIGRvbid0IG5lZWQgYW55 IG9mIHRoZSBmb2xsb3dpbmcgc3R1ZiovDQorICAgIC8qIElkbGUgdGFza3MgZG9uJ3QgbmVlZCBh bnkgb2YgdGhlIGZvbGxvd2luZyBzdHVmICovDQogICAgIGlmICggaXNfaWRsZV92Y3B1KGN1cnJl bnQpICkNCiAgICAgICAgIGdvdG8gY2hlY2tfd2FpdHE7DQotIA0KLSAgICAvKiBjcmVhdGUgbG9j YWwgc3RhdGUgb2YgdGhlIHN0YXR1cyBvZiB0aGUgZG9tYWluLCBpbiBvcmRlciB0byBhdm9pZA0K LSAgICAgICBpbmNvbnNpc3RlbnQgc3RhdGUgZHVyaW5nIHNjaGVkdWxpbmcgZGVjaXNpb25zLCBi ZWNhdXNlIGRhdGEgZm9yDQotICAgICAgIHZjcHVfcnVubmFibGUgaXMgbm90IHByb3RlY3RlZCBi eSB0aGUgc2NoZWR1bGluZyBsb2NrISovDQorDQorICAgIC8qDQorICAgICAqIENyZWF0ZSBsb2Nh bCBzdGF0ZSBvZiB0aGUgc3RhdHVzIG9mIHRoZSBkb21haW4sIGluIG9yZGVyIHRvIGF2b2lkDQor ICAgICAqIGluY29uc2lzdGVudCBzdGF0ZSBkdXJpbmcgc2NoZWR1bGluZyBkZWNpc2lvbnMsIGJl Y2F1c2UgZGF0YSBmb3INCisgICAgICogdmNwdV9ydW5uYWJsZSBpcyBub3QgcHJvdGVjdGVkIGJ5 IHRoZSBzY2hlZHVsaW5nIGxvY2shDQorICAgICAqLw0KICAgICBpZiAoICF2Y3B1X3J1bm5hYmxl KGN1cnJlbnQpICkNCiAgICAgICAgIGluZi0+c3RhdHVzIHw9IFNFREZfQVNMRUVQOw0KICANCkBA IC04MDQsNyArNzYzLDcgQEAgc3RhdGljIHN0cnVjdCB0YXNrX3NsaWNlIHNlZGZfZG9fc2NoZWR1 bA0KIA0KICAgICBpZiAoIHVubGlrZWx5KGV4dHJhX3J1bnMoaW5mKSkgKQ0KICAgICB7DQotICAg ICAgICAvKnNwZWNpYWwgdHJlYXRtZW50IG9mIGRvbWFpbnMgcnVubmluZyBpbiBleHRyYSB0aW1l Ki8NCisgICAgICAgIC8qIFNwZWNpYWwgdHJlYXRtZW50IG9mIGRvbWFpbnMgcnVubmluZyBpbiBl eHRyYSB0aW1lICovDQogICAgICAgICBkZXNjaGVkX2V4dHJhX2RvbShub3csIGN1cnJlbnQpOw0K ICAgICB9DQogICAgIGVsc2UgDQpAQCAtODE0LDEwICs3NzMsMTIgQEAgc3RhdGljIHN0cnVjdCB0 YXNrX3NsaWNlIHNlZGZfZG9fc2NoZWR1bA0KICBjaGVja193YWl0cToNCiAgICAgdXBkYXRlX3F1 ZXVlcyhub3csIHJ1bnEsIHdhaXRxKTsNCiANCi0gICAgLypub3cgc2ltcGx5IHBpY2sgdGhlIGZp cnN0IGRvbWFpbiBmcm9tIHRoZSBydW5xdWV1ZSwgd2hpY2ggaGFzIHRoZQ0KLSAgICAgIGVhcmxp ZXN0IGRlYWRsaW5lLCBiZWNhdXNlIHRoZSBsaXN0IGlzIHNvcnRlZCovDQotIA0KLSAgICAvKiBU YXNrbGV0IHdvcmsgKHdoaWNoIHJ1bnMgaW4gaWRsZSBWQ1BVIGNvbnRleHQpIG92ZXJyaWRlcyBh bGwgZWxzZS4gKi8NCisgICAgLyoNCisgICAgICogTm93IHNpbXBseSBwaWNrIHRoZSBmaXJzdCBk b21haW4gZnJvbSB0aGUgcnVucXVldWUsIHdoaWNoIGhhcyB0aGUNCisgICAgICogZWFybGllc3Qg ZGVhZGxpbmUsIGJlY2F1c2UgdGhlIGxpc3QgaXMgc29ydGVkDQorICAgICAqDQorICAgICAqIFRh c2tsZXQgd29yayAod2hpY2ggcnVucyBpbiBpZGxlIFZDUFUgY29udGV4dCkgb3ZlcnJpZGVzIGFs bCBlbHNlLg0KKyAgICAgKi8NCiAgICAgaWYgKCB0YXNrbGV0X3dvcmtfc2NoZWR1bGVkIHx8DQog ICAgICAgICAgKGxpc3RfZW1wdHkocnVucSkgJiYgbGlzdF9lbXB0eSh3YWl0cSkpIHx8DQogICAg ICAgICAgdW5saWtlbHkoIWNwdW1hc2tfdGVzdF9jcHUoY3B1LCBTRURGX0NQVU9OTElORShwZXJf Y3B1KGNwdXBvb2wsIGNwdSkpKSkgKQ0KQEAgLTgzMyw5ICs3OTQsMTEgQEAgc3RhdGljIHN0cnVj dCB0YXNrX3NsaWNlIHNlZGZfZG9fc2NoZWR1bA0KICAgICAgICAgew0KICAgICAgICAgICAgIHdh aXRpbmYgID0gbGlzdF9lbnRyeSh3YWl0cS0+bmV4dCwNCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgc3RydWN0IHNlZGZfdmNwdV9pbmZvLGxpc3QpOw0KLSAgICAgICAgICAgIC8q cmVydW4gc2NoZWR1bGVyLCB3aGVuIHNjaGVkdWxlZCBkb21haW4gcmVhY2hlcyBpdCdzDQotICAg ICAgICAgICAgICBlbmQgb2Ygc2xpY2Ugb3IgdGhlIGZpcnN0IGRvbWFpbiBmcm9tIHRoZSB3YWl0 cXVldWUNCi0gICAgICAgICAgICAgIGdldHMgcmVhZHkqLw0KKyAgICAgICAgICAgIC8qDQorICAg ICAgICAgICAgICogUmVydW4gc2NoZWR1bGVyLCB3aGVuIHNjaGVkdWxlZCBkb21haW4gcmVhY2hl cyBpdCdzDQorICAgICAgICAgICAgICogZW5kIG9mIHNsaWNlIG9yIHRoZSBmaXJzdCBkb21haW4g ZnJvbSB0aGUgd2FpdHF1ZXVlDQorICAgICAgICAgICAgICogZ2V0cyByZWFkeS4NCisgICAgICAg ICAgICAgKi8NCiAgICAgICAgICAgICByZXQudGltZSA9IE1JTihub3cgKyBydW5pbmYtPnNsaWNl IC0gcnVuaW5mLT5jcHV0aW1lLA0KICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBFUklPRF9C RUdJTih3YWl0aW5mKSkgLSBub3c7DQogICAgICAgICB9DQpAQCAtODQ3LDE0ICs4MTAsMTggQEAg c3RhdGljIHN0cnVjdCB0YXNrX3NsaWNlIHNlZGZfZG9fc2NoZWR1bA0KICAgICBlbHNlDQogICAg IHsNCiAgICAgICAgIHdhaXRpbmYgID0gbGlzdF9lbnRyeSh3YWl0cS0+bmV4dCxzdHJ1Y3Qgc2Vk Zl92Y3B1X2luZm8sIGxpc3QpOw0KLSAgICAgICAgLyp3ZSBjb3VsZCBub3QgZmluZCBhbnkgc3Vp dGFibGUgZG9tYWluIA0KLSAgICAgICAgICA9PiBsb29rIGZvciBkb21haW5zIHRoYXQgYXJlIGF3 YXJlIG9mIGV4dHJhdGltZSovDQorICAgICAgICAvKg0KKyAgICAgICAgICogV2UgY291bGQgbm90 IGZpbmQgYW55IHN1aXRhYmxlIGRvbWFpbiANCisgICAgICAgICAqID0+IGxvb2sgZm9yIGRvbWFp bnMgdGhhdCBhcmUgYXdhcmUgb2YgZXh0cmF0aW1lDQorICAgICAgICAgKi8NCiAgICAgICAgIHJl dCA9IHNlZGZfZG9fZXh0cmFfc2NoZWR1bGUobm93LCBQRVJJT0RfQkVHSU4od2FpdGluZiksDQog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGV4dHJhcSwgY3B1KTsNCiAgICAg fQ0KIA0KLSAgICAvKlRPRE86IERvIHNvbWV0aGluZyBVU0VGVUwgd2hlbiB0aGlzIGhhcHBlbnMg YW5kIGZpbmQgb3V0LCB3aHkgaXQNCi0gICAgICBzdGlsbCBjYW4gaGFwcGVuISEhKi8NCisgICAg LyoNCisgICAgICogVE9ETzogRG8gc29tZXRoaW5nIFVTRUZVTCB3aGVuIHRoaXMgaGFwcGVucyBh bmQgZmluZCBvdXQsIHdoeSBpdA0KKyAgICAgKiBzdGlsbCBjYW4gaGFwcGVuISEhDQorICAgICAq Lw0KICAgICBpZiAoIHJldC50aW1lIDwgMCkNCiAgICAgew0KICAgICAgICAgcHJpbnRrKCJPdWNo ISBXZSBhcmUgc2VyaW91c2x5IEJFSElORCBzY2hlZHVsZSEgJSJQUklpNjQiXG4iLA0KQEAgLTg3 NCw5ICs4NDEsNiBAQCBzdGF0aWMgc3RydWN0IHRhc2tfc2xpY2Ugc2VkZl9kb19zY2hlZHVsDQog DQogc3RhdGljIHZvaWQgc2VkZl9zbGVlcChjb25zdCBzdHJ1Y3Qgc2NoZWR1bGVyICpvcHMsIHN0 cnVjdCB2Y3B1ICpkKQ0KIHsNCi0gICAgUFJJTlQoMiwic2VkZl9zbGVlcCB3YXMgY2FsbGVkLCBk b21haW4taWQgJWkuJWlcbiIsDQotICAgICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBkLT52 Y3B1X2lkKTsNCi0gDQogICAgIGlmICggaXNfaWRsZV92Y3B1KGQpICkNCiAgICAgICAgIHJldHVy bjsNCiANCkBAIC04OTgsNyArODYyLDggQEAgc3RhdGljIHZvaWQgc2VkZl9zbGVlcChjb25zdCBz dHJ1Y3Qgc2NoZQ0KIH0NCiANCiANCi0vKiBUaGlzIGZ1bmN0aW9uIHdha2VzIHVwIGEgZG9tYWlu LCBpLmUuIG1vdmVzIHRoZW0gaW50byB0aGUgd2FpdHF1ZXVlDQorLyoNCisgKiBUaGlzIGZ1bmN0 aW9uIHdha2VzIHVwIGEgZG9tYWluLCBpLmUuIG1vdmVzIHRoZW0gaW50byB0aGUgd2FpdHF1ZXVl DQogICogdGhpbmdzIHRvIG1lbnRpb24gYXJlOiBhZG1pc3Npb24gY29udHJvbCBpcyB0YWtpbmcg cGxhY2Ugbm93aGVyZSBhdA0KICAqIHRoZSBtb21lbnQsIHNvIHdlIGNhbid0IGJlIHN1cmUsIHdo ZXRoZXIgaXQgaXMgc2FmZSB0byB3YWtlIHRoZSBkb21haW4NCiAgKiB1cCBhdCBhbGwuIEFueXdh eSwgZXZlbiBpZiBpdCBpcyBzYWZlICh0b3RhbCBjcHUgdXNhZ2UgPD0xMDAlKSB0aGVyZSBhcmUN CkBAIC05NzIsMjcgKzkzNywzMSBAQCBzdGF0aWMgdm9pZCBzZWRmX3NsZWVwKGNvbnN0IHN0cnVj dCBzY2hlDQogc3RhdGljIHZvaWQgdW5ibG9ja19zaG9ydF9leHRyYV9zdXBwb3J0KA0KICAgICBz dHJ1Y3Qgc2VkZl92Y3B1X2luZm8qIGluZiwgc190aW1lX3Qgbm93KQ0KIHsNCi0gICAgLyp0aGlz IHVuYmxvY2tpbmcgc2NoZW1lIHRyaWVzIHRvIHN1cHBvcnQgdGhlIGRvbWFpbiwgYnkgYXNzaWdu aW5nIGl0DQotICAgIGEgcHJpb3JpdHkgaW4gZXh0cmF0aW1lIGRpc3RyaWJ1dGlvbiBhY2NvcmRp bmcgdG8gdGhlIGxvc3Mgb2YgdGltZQ0KLSAgICBpbiB0aGlzIHNsaWNlIGR1ZSB0byBibG9ja2lu ZyovDQorICAgIC8qDQorICAgICAqIFRoaXMgdW5ibG9ja2luZyBzY2hlbWUgdHJpZXMgdG8gc3Vw cG9ydCB0aGUgZG9tYWluLCBieSBhc3NpZ25pbmcgaXQNCisgICAgICogYSBwcmlvcml0eSBpbiBl eHRyYXRpbWUgZGlzdHJpYnV0aW9uIGFjY29yZGluZyB0byB0aGUgbG9zcyBvZiB0aW1lDQorICAg ICAqIGluIHRoaXMgc2xpY2UgZHVlIHRvIGJsb2NraW5nDQorICAgICAqLw0KICAgICBzX3RpbWVf dCBwZW47DQogIA0KLSAgICAvKm5vIG1vcmUgcmVhbHRpbWUgZXhlY3V0aW9uIGluIHRoaXMgcGVy aW9kISovDQorICAgIC8qIE5vIG1vcmUgcmVhbHRpbWUgZXhlY3V0aW9uIGluIHRoaXMgcGVyaW9k ISAqLw0KICAgICBpbmYtPmRlYWRsX2FicyArPSBpbmYtPnBlcmlvZDsNCiAgICAgaWYgKCBsaWtl bHkoaW5mLT5ibG9ja19hYnMpICkNCiAgICAgew0KLSAgICAgICAgLy90cmVhdCBibG9ja2VkIHRp bWUgYXMgY29uc3VtZWQgYnkgdGhlIGRvbWFpbiovDQorICAgICAgICAvKiBUcmVhdCBibG9ja2Vk IHRpbWUgYXMgY29uc3VtZWQgYnkgdGhlIGRvbWFpbiAqLw0KICAgICAgICAgLyppbmYtPmNwdXRp bWUgKz0gbm93IC0gaW5mLT5ibG9ja19hYnM7Ki8NCi0gICAgICAgIC8qcGVuYWx0eSBpcyB0aW1l IHRoZSBkb21haW4gd291bGQgaGF2ZQ0KLSAgICAgICAgICBoYWQgaWYgaXQgY29udGludWVkIHRv IHJ1biAqLw0KKyAgICAgICAgLyoNCisgICAgICAgICAqIFBlbmFsdHkgaXMgdGltZSB0aGUgZG9t YWluIHdvdWxkIGhhdmUNCisgICAgICAgICAqIGhhZCBpZiBpdCBjb250aW51ZWQgdG8gcnVuLg0K KyAgICAgICAgICovDQogICAgICAgICBwZW4gPSAoaW5mLT5zbGljZSAtIGluZi0+Y3B1dGltZSk7 DQogICAgICAgICBpZiAoIHBlbiA8IDAgKQ0KICAgICAgICAgICAgIHBlbiA9IDA7DQotICAgICAg ICAvKmFjY3VtdWxhdGUgYWxsIHBlbmFsdGllcyBvdmVyIHRoZSBwZXJpb2RzKi8NCisgICAgICAg IC8qIEFjY3VtdWxhdGUgYWxsIHBlbmFsdGllcyBvdmVyIHRoZSBwZXJpb2RzICovDQogICAgICAg ICAvKmluZi0+c2hvcnRfYmxvY2tfbG9zdF90b3QgKz0gcGVuOyovDQotICAgICAgICAvKnNldCBw ZW5hbHR5IHRvIHRoZSBjdXJyZW50IHZhbHVlKi8NCisgICAgICAgIC8qIFNldCBwZW5hbHR5IHRv IHRoZSBjdXJyZW50IHZhbHVlICovDQogICAgICAgICBpbmYtPnNob3J0X2Jsb2NrX2xvc3RfdG90 ID0gcGVuOw0KLSAgICAgICAgLypub3Qgc3VyZSB3aGljaCBvbmUgaXMgYmV0dGVyLi4gYnV0IHNl ZW1zIHRvIHdvcmsgd2VsbC4uLiovDQorICAgICAgICAvKiBOb3Qgc3VyZSB3aGljaCBvbmUgaXMg YmV0dGVyLi4gYnV0IHNlZW1zIHRvIHdvcmsgd2VsbC4uLiAqLw0KICAgDQogICAgICAgICBpZiAo IGluZi0+c2hvcnRfYmxvY2tfbG9zdF90b3QgKQ0KICAgICAgICAgew0KQEAgLTEwMDIsMjggKzk3 MSwzMSBAQCBzdGF0aWMgdm9pZCB1bmJsb2NrX3Nob3J0X2V4dHJhX3N1cHBvcnQoDQogICAgICAg ICAgICAgaW5mLT5wZW5fZXh0cmFfYmxvY2tzKys7DQogI2VuZGlmDQogICAgICAgICAgICAgaWYg KCBleHRyYXFfb24oaW5mLT52Y3B1LCBFWFRSQV9QRU5fUSkgKQ0KLSAgICAgICAgICAgICAgICAv KnJlbW92ZSBkb21haW4gZm9yIHBvc3NpYmxlIHJlc29ydGluZyEqLw0KKyAgICAgICAgICAgICAg ICAvKiBSZW1vdmUgZG9tYWluIGZvciBwb3NzaWJsZSByZXNvcnRpbmchICovDQogICAgICAgICAg ICAgICAgIGV4dHJhcV9kZWwoaW5mLT52Y3B1LCBFWFRSQV9QRU5fUSk7DQogICAgICAgICAgICAg ZWxzZQ0KLSAgICAgICAgICAgICAgICAvKnJlbWVtYmVyIHRoYXQgd2Ugd2FudCB0byBiZSBvbiB0 aGUgcGVuYWx0eSBxDQotICAgICAgICAgICAgICAgICAgc28gdGhhdCB3ZSBjYW4gY29udGludWUg d2hlbiB3ZSAodW4tKWJsb2NrDQotICAgICAgICAgICAgICAgICAgaW4gcGVuYWx0eS1leHRyYXRp bWUqLw0KKyAgICAgICAgICAgICAgICAvKg0KKyAgICAgICAgICAgICAgICAgKiBSZW1lbWJlciB0 aGF0IHdlIHdhbnQgdG8gYmUgb24gdGhlIHBlbmFsdHkgcQ0KKyAgICAgICAgICAgICAgICAgKiBz byB0aGF0IHdlIGNhbiBjb250aW51ZSB3aGVuIHdlICh1bi0pYmxvY2sNCisgICAgICAgICAgICAg ICAgICogaW4gcGVuYWx0eS1leHRyYXRpbWUNCisgICAgICAgICAgICAgICAgICovDQogICAgICAg ICAgICAgICAgIGluZi0+c3RhdHVzIHw9IEVYVFJBX1dBTlRfUEVOX1E7DQogICAgDQotICAgICAg ICAgICAgLyoocmUtKWFkZCBkb21haW4gdG8gdGhlIHBlbmFsdHkgZXh0cmFxKi8NCisgICAgICAg ICAgICAvKiAocmUtKWFkZCBkb21haW4gdG8gdGhlIHBlbmFsdHkgZXh0cmFxICovDQogICAgICAg ICAgICAgZXh0cmFxX2FkZF9zb3J0X3VwZGF0ZShpbmYtPnZjcHUsIEVYVFJBX1BFTl9RLCAwKTsN CiAgICAgICAgIH0NCiAgICAgfQ0KIA0KLSAgICAvKmdpdmUgaXQgYSBmcmVzaCBzbGljZSBpbiB0 aGUgbmV4dCBwZXJpb2QhKi8NCisgICAgLyogR2l2ZSBpdCBhIGZyZXNoIHNsaWNlIGluIHRoZSBu ZXh0IHBlcmlvZCEgKi8NCiAgICAgaW5mLT5jcHV0aW1lID0gMDsNCiB9DQogDQogDQogc3RhdGlj IHZvaWQgdW5ibG9ja19sb25nX2NvbnNfYihzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8qIGluZixzX3Rp bWVfdCBub3cpDQogew0KLSAgICAvKkNvbnNlcnZhdGl2ZSAyYiovDQotICAgIC8qVHJlYXQgdGhl IHVuYmxvY2tpbmcgdGltZSBhcyBhIHN0YXJ0IG9mIGEgbmV3IHBlcmlvZCAqLw0KKyAgICAvKiBD b25zZXJ2YXRpdmUgMmIgKi8NCisNCisgICAgLyogVHJlYXQgdGhlIHVuYmxvY2tpbmcgdGltZSBh cyBhIHN0YXJ0IG9mIGEgbmV3IHBlcmlvZCAqLw0KICAgICBpbmYtPmRlYWRsX2FicyA9IG5vdyAr IGluZi0+cGVyaW9kOw0KICAgICBpbmYtPmNwdXRpbWUgPSAwOw0KIH0NCkBAIC0xMDQ2LDE1ICsx MDE4LDE3IEBAIHN0YXRpYyBpbmxpbmUgaW50IGdldF9ydW5fdHlwZShzdHJ1Y3QgdmMNCiB9DQog DQogDQotLypDb21wYXJlcyB0d28gZG9tYWlucyBpbiB0aGUgcmVsYXRpb24gb2Ygd2hldGhlciB0 aGUgb25lIGlzIGFsbG93ZWQgdG8NCi0gIGludGVycnVwdCB0aGUgb3RoZXJzIGV4ZWN1dGlvbi4N Ci0gIEl0IHJldHVybnMgdHJ1ZSAoIT0wKSBpZiBhIHN3aXRjaCB0byB0aGUgb3RoZXIgZG9tYWlu IGlzIGdvb2QuDQotICBDdXJyZW50IFByaW9yaXR5IHNjaGVtZSBpcyBhcyBmb2xsb3dzOg0KLSAg IEVERiA+IEwwIChwZW5hbHR5IGJhc2VkKSBleHRyYS10aW1lID4gDQotICAgTDEgKHV0aWxpemF0 aW9uKSBleHRyYS10aW1lID4gaWRsZS1kb21haW4NCi0gIEluIHRoZSBzYW1lIGNsYXNzIHByaW9y aXRpZXMgYXJlIGFzc2lnbmVkIGFzIGZvbGxvd2luZzoNCi0gICBFREY6IGVhcmx5IGRlYWRsaW5l ID4gbGF0ZSBkZWFkbGluZQ0KLSAgIEwwIGV4dHJhLXRpbWU6IGxvd2VyIHNjb3JlID4gaGlnaGVy IHNjb3JlKi8NCisvKg0KKyAqIENvbXBhcmVzIHR3byBkb21haW5zIGluIHRoZSByZWxhdGlvbiBv ZiB3aGV0aGVyIHRoZSBvbmUgaXMgYWxsb3dlZCB0bw0KKyAqIGludGVycnVwdCB0aGUgb3RoZXJz IGV4ZWN1dGlvbi4NCisgKiBJdCByZXR1cm5zIHRydWUgKCE9MCkgaWYgYSBzd2l0Y2ggdG8gdGhl IG90aGVyIGRvbWFpbiBpcyBnb29kLg0KKyAqIEN1cnJlbnQgUHJpb3JpdHkgc2NoZW1lIGlzIGFz IGZvbGxvd3M6DQorICogIEVERiA+IEwwIChwZW5hbHR5IGJhc2VkKSBleHRyYS10aW1lID4gDQor ICogIEwxICh1dGlsaXphdGlvbikgZXh0cmEtdGltZSA+IGlkbGUtZG9tYWluDQorICogSW4gdGhl IHNhbWUgY2xhc3MgcHJpb3JpdGllcyBhcmUgYXNzaWduZWQgYXMgZm9sbG93aW5nOg0KKyAqICBF REY6IGVhcmx5IGRlYWRsaW5lID4gbGF0ZSBkZWFkbGluZQ0KKyAqICBMMCBleHRyYS10aW1lOiBs b3dlciBzY29yZSA+IGhpZ2hlciBzY29yZQ0KKyAqLw0KIHN0YXRpYyBpbmxpbmUgaW50IHNob3Vs ZF9zd2l0Y2goc3RydWN0IHZjcHUgKmN1ciwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHN0cnVjdCB2Y3B1ICpvdGhlciwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHNfdGltZV90IG5vdykNCkBAIC0xMDYzLDI2ICsxMDM3LDI1IEBAIHN0YXRpYyBpbmxpbmUgaW50 IHNob3VsZF9zd2l0Y2goc3RydWN0IHYNCiAgICAgY3VyX2luZiAgID0gRURPTV9JTkZPKGN1cik7 DQogICAgIG90aGVyX2luZiA9IEVET01fSU5GTyhvdGhlcik7DQogIA0KLSAgICAvKiBDaGVjayB3 aGV0aGVyIHdlIG5lZWQgdG8gbWFrZSBhbiBlYXJsaWVyIHNjaGVkdWxpbmcgZGVjaXNpb24uICov DQorICAgIC8qIENoZWNrIHdoZXRoZXIgd2UgbmVlZCB0byBtYWtlIGFuIGVhcmxpZXIgc2NoZWR1 bGluZyBkZWNpc2lvbiAqLw0KICAgICBpZiAoIFBFUklPRF9CRUdJTihvdGhlcl9pbmYpIDwgDQog ICAgICAgICAgQ1BVX0lORk8ob3RoZXItPnByb2Nlc3NvciktPmN1cnJlbnRfc2xpY2VfZXhwaXJl cyApDQogICAgICAgICByZXR1cm4gMTsNCiANCi0gICAgLyogTm8gdGltaW5nLWJhc2VkIHN3aXRj aGVzIG5lZWQgdG8gYmUgdGFrZW4gaW50byBhY2NvdW50IGhlcmUuICovDQorICAgIC8qIE5vIHRp bWluZy1iYXNlZCBzd2l0Y2hlcyBuZWVkIHRvIGJlIHRha2VuIGludG8gYWNjb3VudCBoZXJlICov DQogICAgIHN3aXRjaCAoIGdldF9ydW5fdHlwZShjdXIpICkNCiAgICAgew0KICAgICBjYXNlIERP TUFJTl9FREY6DQotICAgICAgICAvKiBEbyBub3QgaW50ZXJydXB0IGEgcnVubmluZyBFREYgZG9t YWluLiAqLw0KKyAgICAgICAgLyogRG8gbm90IGludGVycnVwdCBhIHJ1bm5pbmcgRURGIGRvbWFp biAqLw0KICAgICAgICAgcmV0dXJuIDA7DQogICAgIGNhc2UgRE9NQUlOX0VYVFJBX1BFTjoNCi0g ICAgICAgIC8qIENoZWNrIHdoZXRoZXIgd2UgYWxzbyB3YW50IHRoZSBMMCBleC1xIHdpdGggbG93 ZXIgc2NvcmUuICovDQorICAgICAgICAvKiBDaGVjayB3aGV0aGVyIHdlIGFsc28gd2FudCB0aGUg TDAgZXgtcSB3aXRoIGxvd2VyIHNjb3JlICovDQogICAgICAgICByZXR1cm4gKChvdGhlcl9pbmYt PnN0YXR1cyAmIEVYVFJBX1dBTlRfUEVOX1EpICYmDQogICAgICAgICAgICAgICAgIChvdGhlcl9p bmYtPnNjb3JlW0VYVFJBX1BFTl9RXSA8IA0KICAgICAgICAgICAgICAgICAgY3VyX2luZi0+c2Nv cmVbRVhUUkFfUEVOX1FdKSk7DQogICAgIGNhc2UgRE9NQUlOX0VYVFJBX1VUSUw6DQogICAgICAg ICAvKiBDaGVjayB3aGV0aGVyIHdlIHdhbnQgdGhlIEwwIGV4dHJhcS4gRG9uJ3QNCi0gICAgICAg ICAqIHN3aXRjaCBpZiBib3RoIGRvbWFpbnMgd2FudCBMMSBleHRyYXEuDQotICAgICAgICAgKi8N CisgICAgICAgICAqIHN3aXRjaCBpZiBib3RoIGRvbWFpbnMgd2FudCBMMSBleHRyYXEuICovDQog ICAgICAgICByZXR1cm4gISEob3RoZXJfaW5mLT5zdGF0dXMgJiBFWFRSQV9XQU5UX1BFTl9RKTsN CiAgICAgY2FzZSBET01BSU5fSURMRToNCiAgICAgICAgIHJldHVybiAxOw0KQEAgLTEwOTYsMTgg KzEwNjksMTEgQEAgc3RhdGljIHZvaWQgc2VkZl93YWtlKGNvbnN0IHN0cnVjdCBzY2hlZA0KICAg ICBzX3RpbWVfdCAgICAgICAgICAgICAgbm93ID0gTk9XKCk7DQogICAgIHN0cnVjdCBzZWRmX3Zj cHVfaW5mbyogaW5mID0gRURPTV9JTkZPKGQpOw0KIA0KLSAgICBQUklOVCgzLCAic2VkZl93YWtl IHdhcyBjYWxsZWQsIGRvbWFpbi1pZCAlaS4laVxuIixkLT5kb21haW4tPmRvbWFpbl9pZCwNCi0g ICAgICAgICAgZC0+dmNwdV9pZCk7DQotDQogICAgIGlmICggdW5saWtlbHkoaXNfaWRsZV92Y3B1 KGQpKSApDQogICAgICAgICByZXR1cm47DQogICAgDQogICAgIGlmICggdW5saWtlbHkoX190YXNr X29uX3F1ZXVlKGQpKSApDQotICAgIHsNCi0gICAgICAgIFBSSU5UKDMsIlx0ZG9tYWluICVpLiVp IGlzIGFscmVhZHkgaW4gc29tZSBxdWV1ZVxuIiwNCi0gICAgICAgICAgICAgIGQtPmRvbWFpbi0+ ZG9tYWluX2lkLCBkLT52Y3B1X2lkKTsNCiAgICAgICAgIHJldHVybjsNCi0gICAgfQ0KIA0KICAg ICBBU1NFUlQoIXNlZGZfcnVubmFibGUoZCkpOw0KICAgICBpbmYtPnN0YXR1cyAmPSB+U0VERl9B U0xFRVA7DQpAQCAtMTExNiwyOCArMTA4MiwyNSBAQCBzdGF0aWMgdm9pZCBzZWRmX3dha2UoY29u c3Qgc3RydWN0IHNjaGVkDQogIA0KICAgICBpZiAoIHVubGlrZWx5KGluZi0+ZGVhZGxfYWJzID09 IDApICkNCiAgICAgew0KLSAgICAgICAgLyppbml0aWFsIHNldHVwIG9mIHRoZSBkZWFkbGluZSov DQorICAgICAgICAvKiBJbml0aWFsIHNldHVwIG9mIHRoZSBkZWFkbGluZSAqLw0KICAgICAgICAg aW5mLT5kZWFkbF9hYnMgPSBub3cgKyBpbmYtPnNsaWNlOw0KICAgICB9DQogICANCi0gICAgUFJJ TlQoMywgIndha2luZyB1cCBkb21haW4gJWkuJWkgKGRlYWRsPSAlIlBSSXU2NCIgcGVyaW9kPSAl IlBSSXU2NA0KLSAgICAgICAgICAibm93PSAlIlBSSXU2NCIpXG4iLA0KLSAgICAgICAgICBkLT5k b21haW4tPmRvbWFpbl9pZCwgZC0+dmNwdV9pZCwgaW5mLT5kZWFkbF9hYnMsIGluZi0+cGVyaW9k LCBub3cpOw0KLQ0KICNpZmRlZiBTRURGX1NUQVRTIA0KICAgICBpbmYtPmJsb2NrX3RvdCsrOw0K ICNlbmRpZg0KIA0KICAgICBpZiAoIHVubGlrZWx5KG5vdyA8IFBFUklPRF9CRUdJTihpbmYpKSAp DQogICAgIHsNCi0gICAgICAgIFBSSU5UKDQsImV4dHJhdGltZSB1bmJsb2NrXG4iKTsNCi0gICAg ICAgIC8qIHVuYmxvY2tpbmcgaW4gZXh0cmEtdGltZSEgKi8NCisgICAgICAgIC8qIFVuYmxvY2tp bmcgaW4gZXh0cmEtdGltZSEgKi8NCiAgICAgICAgIGlmICggaW5mLT5zdGF0dXMgJiBFWFRSQV9X QU5UX1BFTl9RICkNCiAgICAgICAgIHsNCi0gICAgICAgICAgICAvKndlIGhhdmUgYSBkb21haW4g dGhhdCB3YW50cyBjb21wZW5zYXRpb24NCi0gICAgICAgICAgICAgIGZvciBibG9jayBwZW5hbHR5 IGFuZCBkaWQganVzdCBibG9jayBpbg0KLSAgICAgICAgICAgICAgaXRzIGNvbXBlbnNhdGlvbiB0 aW1lLiBHaXZlIGl0IGFub3RoZXINCi0gICAgICAgICAgICAgIGNoYW5jZSEqLw0KKyAgICAgICAg ICAgIC8qDQorICAgICAgICAgICAgICogV2UgaGF2ZSBhIGRvbWFpbiB0aGF0IHdhbnRzIGNvbXBl bnNhdGlvbg0KKyAgICAgICAgICAgICAqIGZvciBibG9jayBwZW5hbHR5IGFuZCBkaWQganVzdCBi bG9jayBpbg0KKyAgICAgICAgICAgICAqIGl0cyBjb21wZW5zYXRpb24gdGltZS4gR2l2ZSBpdCBh bm90aGVyDQorICAgICAgICAgICAgICogY2hhbmNlIQ0KKyAgICAgICAgICAgICAqLw0KICAgICAg ICAgICAgIGV4dHJhcV9hZGRfc29ydF91cGRhdGUoZCwgRVhUUkFfUEVOX1EsIDApOw0KICAgICAg ICAgfQ0KICAgICAgICAgZXh0cmFxX2NoZWNrX2FkZF91bmJsb2NrZWQoZCwgMCk7DQpAQCAtMTE0 Niw4ICsxMTA5LDcgQEAgc3RhdGljIHZvaWQgc2VkZl93YWtlKGNvbnN0IHN0cnVjdCBzY2hlZA0K ICAgICB7ICANCiAgICAgICAgIGlmICggbm93IDwgaW5mLT5kZWFkbF9hYnMgKQ0KICAgICAgICAg ew0KLSAgICAgICAgICAgIFBSSU5UKDQsInNob3J0IHVuYmxvY2tpbmdcbiIpOw0KLSAgICAgICAg ICAgIC8qc2hvcnQgYmxvY2tpbmcqLw0KKyAgICAgICAgICAgIC8qIFNob3J0IGJsb2NraW5nICov DQogI2lmZGVmIFNFREZfU1RBVFMNCiAgICAgICAgICAgICBpbmYtPnNob3J0X2Jsb2NrX3RvdCsr Ow0KICNlbmRpZg0KQEAgLTExNTcsOCArMTExOSw3IEBAIHN0YXRpYyB2b2lkIHNlZGZfd2FrZShj b25zdCBzdHJ1Y3Qgc2NoZWQNCiAgICAgICAgIH0NCiAgICAgICAgIGVsc2UNCiAgICAgICAgIHsN Ci0gICAgICAgICAgICBQUklOVCg0LCJsb25nIHVuYmxvY2tpbmdcbiIpOw0KLSAgICAgICAgICAg IC8qbG9uZyB1bmJsb2NraW5nKi8NCisgICAgICAgICAgICAvKiBMb25nIHVuYmxvY2tpbmcgKi8N CiAjaWZkZWYgU0VERl9TVEFUUw0KICAgICAgICAgICAgIGluZi0+bG9uZ19ibG9ja190b3QrKzsN CiAjZW5kaWYNCkBAIC0xMTY4LDI0ICsxMTI5LDEzIEBAIHN0YXRpYyB2b2lkIHNlZGZfd2FrZShj b25zdCBzdHJ1Y3Qgc2NoZWQNCiAgICAgICAgIH0NCiAgICAgfQ0KIA0KLSAgICBQUklOVCgzLCAi d29rZSB1cCBkb21haW4gJWkuJWkgKGRlYWRsPSAlIlBSSXU2NCIgcGVyaW9kPSAlIlBSSXU2NA0K LSAgICAgICAgICAibm93PSAlIlBSSXU2NCIpXG4iLA0KLSAgICAgICAgICBkLT5kb21haW4tPmRv bWFpbl9pZCwgZC0+dmNwdV9pZCwgaW5mLT5kZWFkbF9hYnMsDQotICAgICAgICAgIGluZi0+cGVy aW9kLCBub3cpOw0KLQ0KICAgICBpZiAoIFBFUklPRF9CRUdJTihpbmYpID4gbm93ICkNCi0gICAg ew0KICAgICAgICAgX19hZGRfdG9fd2FpdHF1ZXVlX3NvcnQoZCk7DQotICAgICAgICBQUklOVCgz LCJhZGRlZCB0byB3YWl0cVxuIik7DQotICAgIH0NCiAgICAgZWxzZQ0KLSAgICB7DQogICAgICAg ICBfX2FkZF90b19ydW5xdWV1ZV9zb3J0KGQpOw0KLSAgICAgICAgUFJJTlQoMywiYWRkZWQgdG8g cnVucVxuIik7DQotICAgIH0NCiAgDQogI2lmZGVmIFNFREZfU1RBVFMNCi0gICAgLypkbyBzb21l IHN0YXRpc3RpY3MgaGVyZS4uLiovDQorICAgIC8qIERvIHNvbWUgc3RhdGlzdGljcyBoZXJlLi4u ICovDQogICAgIGlmICggaW5mLT5ibG9ja19hYnMgIT0gMCApDQogICAgIHsNCiAgICAgICAgIGlu Zi0+YmxvY2tfdGltZV90b3QgKz0gbm93IC0gaW5mLT5ibG9ja19hYnM7DQpAQCAtMTE5NCwxMiAr MTE0NCwxNCBAQCBzdGF0aWMgdm9pZCBzZWRmX3dha2UoY29uc3Qgc3RydWN0IHNjaGVkDQogICAg IH0NCiAjZW5kaWYNCiANCi0gICAgLypzYW5pdHkgY2hlY2s6IG1ha2Ugc3VyZSBlYWNoIGV4dHJh LWF3YXJlIGRvbWFpbiBJUyBvbiB0aGUgdXRpbC1xISovDQorICAgIC8qIFNhbml0eSBjaGVjazog bWFrZSBzdXJlIGVhY2ggZXh0cmEtYXdhcmUgZG9tYWluIElTIG9uIHRoZSB1dGlsLXEhICovDQog ICAgIEFTU0VSVChJTVBMWShpbmYtPnN0YXR1cyAmIEVYVFJBX0FXQVJFLCBleHRyYXFfb24oZCwg RVhUUkFfVVRJTF9RKSkpOw0KICAgICBBU1NFUlQoX190YXNrX29uX3F1ZXVlKGQpKTsNCi0gICAg LypjaGVjayB3aGV0aGVyIHRoZSBhd2FrZW5lZCB0YXNrIG5lZWRzIHRvIGludm9rZSB0aGUgZG9f c2NoZWR1bGUNCi0gICAgICByb3V0aW5lLiBUcnkgdG8gYXZvaWQgdW5uZWNlc3NhcnkgcnVucyBi dXQ6DQotICAgICAgU2F2ZSBhcHByb3hpbWF0aW9uOiBBbHdheXMgc3dpdGNoIHRvIHNjaGVkdWxl ciEqLw0KKyAgICAvKg0KKyAgICAgKiBDaGVjayB3aGV0aGVyIHRoZSBhd2FrZW5lZCB0YXNrIG5l ZWRzIHRvIGludm9rZSB0aGUgZG9fc2NoZWR1bGUNCisgICAgICogcm91dGluZS4gVHJ5IHRvIGF2 b2lkIHVubmVjZXNzYXJ5IHJ1bnMgYnV0Og0KKyAgICAgKiBTYXZlIGFwcHJveGltYXRpb246IEFs d2F5cyBzd2l0Y2ggdG8gc2NoZWR1bGVyIQ0KKyAgICAgKi8NCiAgICAgQVNTRVJUKGQtPnByb2Nl c3NvciA+PSAwKTsNCiAgICAgQVNTRVJUKGQtPnByb2Nlc3NvciA8IG5yX2NwdV9pZHMpOw0KICAg ICBBU1NFUlQocGVyX2NwdShzY2hlZHVsZV9kYXRhLCBkLT5wcm9jZXNzb3IpLmN1cnIpOw0KQEAg LTEyNDQsNyArMTE5Niw3IEBAIHN0YXRpYyB2b2lkIHNlZGZfZHVtcF9kb21haW4oc3RydWN0IHZj cHUNCiB9DQogDQogDQotLyogZHVtcHMgYWxsIGRvbWFpbnMgb24gdGhlIHNwZWNpZmllZCBjcHUg Ki8NCisvKiBEdW1wcyBhbGwgZG9tYWlucyBvbiB0aGUgc3BlY2lmaWVkIGNwdSAqLw0KIHN0YXRp YyB2b2lkIHNlZGZfZHVtcF9jcHVfc3RhdGUoY29uc3Qgc3RydWN0IHNjaGVkdWxlciAqb3BzLCBp bnQgaSkNCiB7DQogICAgIHN0cnVjdCBsaXN0X2hlYWQgICAgICAqbGlzdCwgKnF1ZXVlLCAqdG1w Ow0KQEAgLTEzMTksNyArMTI3MSw3IEBAIHN0YXRpYyB2b2lkIHNlZGZfZHVtcF9jcHVfc3RhdGUo Y29uc3Qgc3QNCiB9DQogDQogDQotLyogQWRqdXN0cyBwZXJpb2RzIGFuZCBzbGljZXMgb2YgdGhl IGRvbWFpbnMgYWNjb3JkaW5nbHkgdG8gdGhlaXIgd2VpZ2h0cy4gKi8NCisvKiBBZGp1c3RzIHBl cmlvZHMgYW5kIHNsaWNlcyBvZiB0aGUgZG9tYWlucyBhY2NvcmRpbmdseSB0byB0aGVpciB3ZWln aHRzICovDQogc3RhdGljIGludCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBjcHVwb29sICpj LCBzdHJ1Y3QgeGVuX2RvbWN0bF9zY2hlZHVsZXJfb3AgKmNtZCkNCiB7DQogICAgIHN0cnVjdCB2 Y3B1ICpwOw0KQEAgLTEzMzUsNyArMTI4Nyw3IEBAIHN0YXRpYyBpbnQgc2VkZl9hZGp1c3Rfd2Vp Z2h0cyhzdHJ1Y3QgY3ANCiAgICAgICAgIHJldHVybiAtRU5PTUVNOw0KICAgICB9DQogDQotICAg IC8qIFN1bSBhY3Jvc3MgYWxsIHdlaWdodHMuICovDQorICAgIC8qIFN1bSBhY3Jvc3MgYWxsIHdl aWdodHMgKi8NCiAgICAgcmN1X3JlYWRfbG9jaygmZG9tbGlzdF9yZWFkX2xvY2spOw0KICAgICBm b3JfZWFjaF9kb21haW5faW5fY3B1cG9vbCggZCwgYyApDQogICAgIHsNCkBAIC0xMzUwLDExICsx MzAyLDE0IEBAIHN0YXRpYyBpbnQgc2VkZl9hZGp1c3Rfd2VpZ2h0cyhzdHJ1Y3QgY3ANCiAgICAg ICAgICAgICB9DQogICAgICAgICAgICAgZWxzZQ0KICAgICAgICAgICAgIHsNCi0gICAgICAgICAg ICAgICAgLypkb24ndCBtb2RpZnkgZG9tYWlucyB3aG8gZG9uJ3QgaGF2ZSBhIHdlaWdodCwgYnV0 IHN1bQ0KLSAgICAgICAgICAgICAgICAgIHVwIHRoZSB0aW1lIHRoZXkgbmVlZCwgcHJvamVjdGVk IHRvIGEgV0VJR0hUX1BFUklPRCwNCi0gICAgICAgICAgICAgICAgICBzbyB0aGF0IHRoaXMgdGlt ZSBpcyBub3QgZ2l2ZW4gdG8gdGhlIHdlaWdodC1kcml2ZW4NCi0gICAgICAgICAgICAgICAgICBk b21haW5zKi8NCi0gICAgICAgICAgICAgICAgLypjaGVjayBmb3Igb3ZlcmZsb3dzKi8NCisgICAg ICAgICAgICAgICAgLyoNCisgICAgICAgICAgICAgICAgICogRG9uJ3QgbW9kaWZ5IGRvbWFpbnMg d2hvIGRvbid0IGhhdmUgYSB3ZWlnaHQsIGJ1dCBzdW0NCisgICAgICAgICAgICAgICAgICogdXAg dGhlIHRpbWUgdGhleSBuZWVkLCBwcm9qZWN0ZWQgdG8gYSBXRUlHSFRfUEVSSU9ELA0KKyAgICAg ICAgICAgICAgICAgKiBzbyB0aGF0IHRoaXMgdGltZSBpcyBub3QgZ2l2ZW4gdG8gdGhlIHdlaWdo dC1kcml2ZW4NCisgICAgICAgICAgICAgICAgICogIGRvbWFpbnMNCisgICAgICAgICAgICAgICAg ICovDQorDQorICAgICAgICAgICAgICAgIC8qIENoZWNrIGZvciBvdmVyZmxvd3MgKi8NCiAgICAg ICAgICAgICAgICAgQVNTRVJUKChXRUlHSFRfUEVSSU9EIDwgVUxPTkdfTUFYKSANCiAgICAgICAg ICAgICAgICAgICAgICAgICYmIChFRE9NX0lORk8ocCktPnNsaWNlX29yaWcgPCBVTE9OR19NQVgp KTsNCiAgICAgICAgICAgICAgICAgc3VtdFtjcHVdICs9IA0KQEAgLTEzNjUsNyArMTMyMCw3IEBA IHN0YXRpYyBpbnQgc2VkZl9hZGp1c3Rfd2VpZ2h0cyhzdHJ1Y3QgY3ANCiAgICAgfQ0KICAgICBy Y3VfcmVhZF91bmxvY2soJmRvbWxpc3RfcmVhZF9sb2NrKTsNCiANCi0gICAgLyogQWRqdXN0IGFs bCBzbGljZXMgKGFuZCBwZXJpb2RzKSB0byB0aGUgbmV3IHdlaWdodC4gKi8NCisgICAgLyogQWRq dXN0IGFsbCBzbGljZXMgKGFuZCBwZXJpb2RzKSB0byB0aGUgbmV3IHdlaWdodCAqLw0KICAgICBy Y3VfcmVhZF9sb2NrKCZkb21saXN0X3JlYWRfbG9jayk7DQogICAgIGZvcl9lYWNoX2RvbWFpbl9p bl9jcHVwb29sKCBkLCBjICkNCiAgICAgew0KQEAgLTEzOTMsMjAgKzEzNDgsMTUgQEAgc3RhdGlj IGludCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBjcA0KIH0NCiANCiANCi0vKiBzZXQgb3Ig ZmV0Y2ggZG9tYWluIHNjaGVkdWxpbmcgcGFyYW1ldGVycyAqLw0KKy8qIFNldCBvciBmZXRjaCBk b21haW4gc2NoZWR1bGluZyBwYXJhbWV0ZXJzICovDQogc3RhdGljIGludCBzZWRmX2FkanVzdChj b25zdCBzdHJ1Y3Qgc2NoZWR1bGVyICpvcHMsIHN0cnVjdCBkb21haW4gKnAsIHN0cnVjdCB4ZW5f ZG9tY3RsX3NjaGVkdWxlcl9vcCAqb3ApDQogew0KICAgICBzdHJ1Y3QgdmNwdSAqdjsNCiAgICAg aW50IHJjOw0KIA0KLSAgICBQUklOVCgyLCJzZWRmX2FkanVzdCB3YXMgY2FsbGVkLCBkb21haW4t aWQgJWkgbmV3IHBlcmlvZCAlIlBSSXU2NCIgIg0KLSAgICAgICAgICAibmV3IHNsaWNlICUiUFJJ dTY0IlxubGF0ZW5jeSAlIlBSSXU2NCIgZXh0cmE6JXNcbiIsDQotICAgICAgICAgIHAtPmRvbWFp bl9pZCwgb3AtPnUuc2VkZi5wZXJpb2QsIG9wLT51LnNlZGYuc2xpY2UsDQotICAgICAgICAgIG9w LT51LnNlZGYubGF0ZW5jeSwgKG9wLT51LnNlZGYuZXh0cmF0aW1lKT8ieWVzIjoibm8iKTsNCi0N CiAgICAgaWYgKCBvcC0+Y21kID09IFhFTl9ET01DVExfU0NIRURPUF9wdXRpbmZvICkNCiAgICAg ew0KLSAgICAgICAgLyogQ2hlY2sgZm9yIHNhbmUgcGFyYW1ldGVycy4gKi8NCisgICAgICAgIC8q IENoZWNrIGZvciBzYW5lIHBhcmFtZXRlcnMgKi8NCiAgICAgICAgIGlmICggIW9wLT51LnNlZGYu cGVyaW9kICYmICFvcC0+dS5zZWRmLndlaWdodCApDQogICAgICAgICAgICAgcmV0dXJuIC1FSU5W QUw7DQogICAgICAgICBpZiAoIG9wLT51LnNlZGYud2VpZ2h0ICkNCkBAIC0xNDE0LDcgKzEzNjQs NyBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlDQogICAgICAgICAg ICAgaWYgKCAob3AtPnUuc2VkZi5leHRyYXRpbWUgJiBFWFRSQV9BV0FSRSkgJiYNCiAgICAgICAg ICAgICAgICAgICghb3AtPnUuc2VkZi5wZXJpb2QpICkNCiAgICAgICAgICAgICB7DQotICAgICAg ICAgICAgICAgIC8qIFdlaWdodC1kcml2ZW4gZG9tYWlucyB3aXRoIGV4dHJhdGltZSBvbmx5LiAq Lw0KKyAgICAgICAgICAgICAgICAvKiBXZWlnaHQtZHJpdmVuIGRvbWFpbnMgd2l0aCBleHRyYXRp bWUgb25seSAqLw0KICAgICAgICAgICAgICAgICBmb3JfZWFjaF92Y3B1ICggcCwgdiApDQogICAg ICAgICAgICAgICAgIHsNCiAgICAgICAgICAgICAgICAgICAgIEVET01fSU5GTyh2KS0+ZXh0cmF3 ZWlnaHQgPSBvcC0+dS5zZWRmLndlaWdodDsNCkBAIC0xNDI1LDcgKzEzNzUsNyBAQCBzdGF0aWMg aW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlDQogICAgICAgICAgICAgfQ0KICAgICAg ICAgICAgIGVsc2UNCiAgICAgICAgICAgICB7DQotICAgICAgICAgICAgICAgIC8qIFdlaWdodC1k cml2ZW4gZG9tYWlucyB3aXRoIHJlYWwtdGltZSBleGVjdXRpb24uICovDQorICAgICAgICAgICAg ICAgIC8qIFdlaWdodC1kcml2ZW4gZG9tYWlucyB3aXRoIHJlYWwtdGltZSBleGVjdXRpb24gKi8N CiAgICAgICAgICAgICAgICAgZm9yX2VhY2hfdmNwdSAoIHAsIHYgKQ0KICAgICAgICAgICAgICAg ICAgICAgRURPTV9JTkZPKHYpLT53ZWlnaHQgPSBvcC0+dS5zZWRmLndlaWdodDsNCiAgICAgICAg ICAgICB9DQpAQCAtMTQ3Nyw3ICsxNDI3LDYgQEAgc3RhdGljIGludCBzZWRmX2FkanVzdChjb25z dCBzdHJ1Y3Qgc2NoZQ0KICAgICAgICAgb3AtPnUuc2VkZi53ZWlnaHQgICAgPSBFRE9NX0lORk8o cC0+dmNwdVswXSktPndlaWdodDsNCiAgICAgfQ0KIA0KLSAgICBQUklOVCgyLCJzZWRmX2FkanVz dF9maW5pc2hlZFxuIik7DQogICAgIHJldHVybiAwOw0KIH0NCiANCm== --=-DM3xwBkUsBWsFUckworM-- --=-oVXZhmqkWYbyP3+4MWM6 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) iEYEABECAAYFAk7yA2EACgkQk4XaBE3IOsQjHgCgokeOKmICEG21IO9eF+nOwRTE 4HYAoJlFaHcaHVJZC2nqIqROHfizcSkc =ZkFV -----END PGP SIGNATURE----- --=-oVXZhmqkWYbyP3+4MWM6-- --===============2284887627372470128== 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 --===============2284887627372470128==--