From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dario Faggioli Subject: sedf: remove useless tracing printk and harmonize comments style. Date: Tue, 20 Dec 2011 18:47:36 +0100 Message-ID: <1324403256.2632.0.camel@Solace> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="===============4953755209351780878==" 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 --===============4953755209351780878== Content-Type: multipart/signed; micalg="pgp-sha1"; protocol="application/pgp-signature"; boundary="=-4GhoPkvT2knwTpwLdibp" --=-4GhoPkvT2knwTpwLdibp Content-Type: multipart/mixed; boundary="=-3p5/0djGq6n5G1gGRftX" --=-3p5/0djGq6n5G1gGRftX 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 17d99691e0ec xen/common/sched_sedf.c --- a/xen/common/sched_sedf.c Tue Dec 20 16:39:56 2011 +0000 +++ b/xen/common/sched_sedf.c Tue Dec 20 17:32:52 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,16 @@ 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,13 +169,7 @@ 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 + /* Iterate through all elements to find our "hole" and on our way * update all the other scores. */ list_for_each ( cur, EXTRAQ(d->processor, i) ) @@ -193,25 +178,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 +199,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 +215,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 +228,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 +240,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 +263,26 @@ 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 @@ -445,22 +401,21 @@ static int sedf_pick_cpu(const struct sc return cpumask_first(&online_affinity); } =20 -/* - * Handles the rescheduling & bookkeeping of domains running in their + +/* Handles the rescheduling & bookkeeping of domains running in their * guaranteed timeslice. */ static void desched_edf_dom(s_time_t now, struct vcpu* d) { 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 - /* - * Scheduling decisions which don't remove the running domain from the + /* Scheduling decisions which don't remove the running domain from the * runq.=20 */ if ( (inf->cputime < inf->slice) && sedf_runnable(d) ) @@ -468,8 +423,7 @@ static void desched_edf_dom(s_time_t now =20 __del_from_queue(d); =20 - /* - * Manage bookkeeping (i.e. calculate next deadline, memorise + /* Manage bookkeeping (i.e. calculate next deadline, memorise * overrun-time of slice) of finished domains. */ if ( inf->cputime >=3D inf->slice ) @@ -478,30 +432,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,73 +475,59 @@ 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 + /* Check for the first elements of the waitqueue, whether their * next period has already started. */ 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) || (curinf->cputime > curinf->slice)) ) { - /* - * We missed the deadline or the slice was already finished. + /* 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 + /* If we are still behind: modulo arithmetic, force deadline * to be in future and aligned to period borders. */ if ( unlikely(curinf->deadl_abs < now) ) @@ -596,7 +536,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 +546,16 @@ 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 */ + * 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 +564,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 +591,56 @@ 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 +672,9 @@ 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 +688,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]); @@ -773,10 +714,11 @@ 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*/ + * 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 +731,14 @@ 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 +747,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 +757,11 @@ 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 +777,10 @@ 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 +792,15 @@ 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 +820,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 @@ -972,27 +915,29 @@ 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 +947,30 @@ 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 +993,16 @@ 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,19 +1011,19 @@ 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])); @@ -1096,18 +1044,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 +1057,24 @@ 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 +1083,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 +1093,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 +1103,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 +1118,13 @@ 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 +1169,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 +1244,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 +1260,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 +1275,13 @@ 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 +1292,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 +1320,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 +1336,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 +1347,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; } @@ -1435,8 +1357,7 @@ static int sedf_adjust(const struct sche /* Time-driven domains. */ for_each_vcpu ( p, v ) { - /* - * Sanity checking: note that disabling extra weight requi= res + /* Sanity checking: note that disabling extra weight requi= res * that we set a non-zero slice. */ if ( (op->u.sedf.period > PERIOD_MAX) || @@ -1477,7 +1398,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) --=-3p5/0djGq6n5G1gGRftX 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 IyBIRyBjaGFuZ2VzZXQgcGF0Y2gNCiMgUGFyZW50IDE3ZDk5NjkxZTBlYzFmYTdiYjcxY2YxOGMx MmNhM2MwNDZjMGM4ZDcNCnNlZGY6IHJlbW92ZSB1c2VsZXNzIHRyYWNpbmcgcHJpbnRrIGFuZCBo YXJtb25pemUgY29tbWVudHMgc3R5bGUuDQoNCnNjaGVkX3NlZGYuYyB1c2VkIG8gaGF2ZSBpdHMg b3duIG1lY2hhbmlzbSBmb3IgcHJvZHVjaW5nIHRyYWNpbmctYWxpa2UNCmtpbmQgb2YgaW5mb3Jt YXRpb24gKGRvbWFpbiBibG9jaywgd2FrZXVwLCBldGMuKS4gTm93YWRheXMsIHdpdGggYW4gZXZl bg0Kbm90IHNvIGhpZ2ggbnVtYmVyIG9mIHBDUFVzL3ZDUFVzLCBqdXN0IHRyeWluZyB0byBlbmFi bGUgdGhpcyBtYWtlcw0KdGhlIHNlcmlhbCBjb25zb2xlIGNvbXBsZXRlbHkgdW51c2FibGUsIHBy b2R1Y2VzIHRvbnMgb2YgdmVyeSBoYXJkIHRvDQpwYXJzZSBhbmQgaW50ZXJwcmVldCBsb2dnaW5n IGFuZCBjYW4gZWFzaWx5IGxpdmVsb2NrIERvbTAuIE1vcmVvdmVyLA0KcHJldHR5IG11Y2ggdGhl IHNhbWUgcmVzdWx0IHRoaXMgaXMgc3RydWdnbGluZyB0byBnZXQgdG8sIGlzIGJldHRlcg0KYWNo aWV2ZWQgYnkgZW5hYmxpbmcgdGhlIHNjaGVkdWxlci1yZWxhdGVkIHRyYWNpbmcgZXZlbnRzLCBh cw0KaXQgaXMgZm9yIHRoZSBvdGhlciBzY2hlZHVsZXJzIChzYXksIGNyZWRpdCBvciBjcmVkaXQy KS4NCg0KRm9yIGFsbCB0aGVzZSByZWFzb25zLCB0aGlzIHJlbW92ZXMgdGhhdCBtYWNoaW5lcnkg Y29tcGxldGVseS4gV2hpbGUgYXQNCml0LCBjaGVjayBpbiBzb21lIGNvc21ldGljcyB0aGF0IGhh cm1vbml6ZSB0aGUgY29tbWVudHMgd2l0aGltIHRoZW1zZWxmDQphbmQgd2l0aCB0aGUgcmVzdCBv ZiB0aGUgY29kZSBiYXNlLg0KDQpTaWduZWQtb2ZmLWJ5OiBEYXJpbyBGYWdnaW9saSA8ZGFyaW8u ZmFnZ2lvbGlAY2l0cml4LmNvbT4NCg0KZGlmZiAtciAxN2Q5OTY5MWUwZWMgeGVuL2NvbW1vbi9z Y2hlZF9zZWRmLmMNCi0tLSBhL3hlbi9jb21tb24vc2NoZWRfc2VkZi5jCVR1ZSBEZWMgMjAgMTY6 Mzk6NTYgMjAxMSArMDAwMA0KKysrIGIveGVuL2NvbW1vbi9zY2hlZF9zZWRmLmMJVHVlIERlYyAy MCAxNzozMjo1MiAyMDExICswMDAwDQpAQCAtMTMsMTQgKzEzLDYgQEANCiAjaW5jbHVkZSA8eGVu 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 bWVfdG90Ow0KIA0KICNpZmRlZiBTRURGX1NUQVRTDQpAQCAtMTU4LDE4ICsxNTEsMTYgQEAgc3Rh dGljIGlubGluZSB2b2lkIGV4dHJhcV9kZWwoc3RydWN0IHZjcA0KIHsNCiAgICAgc3RydWN0IGxp c3RfaGVhZCAqbGlzdCA9IEVYVFJBTElTVChkLGkpOw0KICAgICBBU1NFUlQoZXh0cmFxX29uKGQs aSkpOw0KLSAgICBQUklOVCgzLCAiUmVtb3ZpbmcgZG9tYWluICVpLiVpIGZyb20gTCVpIGV4dHJh cVxuIiwNCi0gICAgICAgICAgZC0+ZG9tYWluLT5kb21haW5faWQsIGQtPnZjcHVfaWQsIGkpOw0K ICAgICBsaXN0X2RlbChsaXN0KTsNCiAgICAgbGlzdC0+bmV4dCA9IE5VTEw7DQogICAgIEFTU0VS VCghZXh0cmFxX29uKGQsIGkpKTsNCiB9DQogDQotLyogYWRkcyBhIGRvbWFpbiB0byB0aGUgcXVl dWUgb2YgcHJvY2Vzc2VzIHdoaWNoIGFyZSBhd2FyZSBvZiBleHRyYSB0aW1lLiBMaXN0DQotICAg aXMgc29ydGVkIGJ5IHNjb3JlLCB3aGVyZSBhIGxvd2VyIHNjb3JlIG1lYW5zIGhpZ2hlciBwcmlv cml0eSBmb3IgYW4gZXh0cmENCi0gICBzbGljZS4gSXQgYWxzbyB1cGRhdGVzIHRoZSBzY29yZSwg Ynkgc2ltcGx5IHN1YnRyYWN0aW5nIGEgZml4ZWQgdmFsdWUgZnJvbQ0KLSAgIGVhY2ggZW50cnks IGluIG9yZGVyIHRvIGF2b2lkIG92ZXJmbG93LiBUaGUgYWxnb3JpdGhtIHdvcmtzIGJ5IHNpbXBs eQ0KLSAgIGNoYXJnaW5nIGVhY2ggZG9tYWluIHRoYXQgcmVjaWV2ZWQgZXh0cmF0aW1lIHdpdGgg YW4gaW52ZXJzZSBvZiBpdHMgd2VpZ2h0Lg0KKy8qIEFkZHMgYSBkb21haW4gdG8gdGhlIHF1ZXVl IG9mIHByb2Nlc3NlcyB3aGljaCBhcmUgYXdhcmUgb2YgZXh0cmEgdGltZS4gTGlzdA0KKyAqIGlz IHNvcnRlZCBieSBzY29yZSwgd2hlcmUgYSBsb3dlciBzY29yZSBtZWFucyBoaWdoZXIgcHJpb3Jp dHkgZm9yIGFuIGV4dHJhDQorICogc2xpY2UuIEl0IGFsc28gdXBkYXRlcyB0aGUgc2NvcmUsIGJ5 IHNpbXBseSBzdWJ0cmFjdGluZyBhIGZpeGVkIHZhbHVlIGZyb20NCisgKiBlYWNoIGVudHJ5LCBp biBvcmRlciB0byBhdm9pZCBvdmVyZmxvdy4gVGhlIGFsZ29yaXRobSB3b3JrcyBieSBzaW1wbHkN CisgKiBjaGFyZ2luZyBlYWNoIGRvbWFpbiB0aGF0IHJlY2lldmVkIGV4dHJhdGltZSB3aXRoIGFu IGludmVyc2Ugb2YgaXRzIHdlaWdodC4NCiAgKi8gDQogc3RhdGljIGlubGluZSB2b2lkIGV4dHJh cV9hZGRfc29ydF91cGRhdGUoc3RydWN0IHZjcHUgKmQsIGludCBpLCBpbnQgc3ViKQ0KIHsNCkBA IC0xNzgsMTMgKzE2OSw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBleHRyYXFfYWRkX3NvcnRfdXBk YXQNCiAgDQogICAgIEFTU0VSVCghZXh0cmFxX29uKGQsaSkpOw0KIA0KLSAgICBQUklOVCgzLCAi QWRkaW5nIGRvbWFpbiAlaS4laSAoc2NvcmU9ICVpLCBzaG9ydF9wZW49ICUiUFJJaTY0IikiDQot ICAgICAgICAgICIgdG8gTCVpIGV4dHJhcVxuIiwNCi0gICAgICAgICAgZC0+ZG9tYWluLT5kb21h aW5faWQsIGQtPnZjcHVfaWQsIEVET01fSU5GTyhkKS0+c2NvcmVbaV0sDQotICAgICAgICAgIEVE T01fSU5GTyhkKS0+c2hvcnRfYmxvY2tfbG9zdF90b3QsIGkpOw0KLQ0KLSAgICAvKg0KLSAgICAg KiBJdGVyYXRlIHRocm91Z2ggYWxsIGVsZW1lbnRzIHRvIGZpbmQgb3VyICJob2xlIiBhbmQgb24g b3VyIHdheQ0KKyAgICAvKiBJdGVyYXRlIHRocm91Z2ggYWxsIGVsZW1lbnRzIHRvIGZpbmQgb3Vy ICJob2xlIiBhbmQgb24gb3VyIHdheQ0KICAgICAgKiB1cGRhdGUgYWxsIHRoZSBvdGhlciBzY29y ZXMuDQogICAgICAqLw0KICAgICBsaXN0X2Zvcl9lYWNoICggY3VyLCBFWFRSQVEoZC0+cHJvY2Vz c29yLCBpKSApDQpAQCAtMTkzLDI1ICsxNzgsMTggQEAgc3RhdGljIGlubGluZSB2b2lkIGV4dHJh cV9hZGRfc29ydF91cGRhdA0KICAgICAgICAgY3VyaW5mLT5zY29yZVtpXSAtPSBzdWI7DQogICAg ICAgICBpZiAoIEVET01fSU5GTyhkKS0+c2NvcmVbaV0gPCBjdXJpbmYtPnNjb3JlW2ldICkNCiAg ICAgICAgICAgICBicmVhazsNCi0gICAgICAgIFBSSU5UKDQsIlx0YmVoaW5kIGRvbWFpbiAlaS4l aSAoc2NvcmU9ICVpKVxuIiwNCi0gICAgICAgICAgICAgIGN1cmluZi0+dmNwdS0+ZG9tYWluLT5k b21haW5faWQsDQotICAgICAgICAgICAgICBjdXJpbmYtPnZjcHUtPnZjcHVfaWQsIGN1cmluZi0+ c2NvcmVbaV0pOw0KICAgICB9DQogDQotICAgIC8qIGN1ciBub3cgY29udGFpbnMgdGhlIGVsZW1l bnQsIGJlZm9yZSB3aGljaCB3ZSdsbCBlbnF1ZXVlLiAqLw0KLSAgICBQUklOVCgzLCAiXHRsaXN0 X2FkZCB0byAlcFxuIiwgY3VyLT5wcmV2KTsNCisgICAgLyogY3VyIG5vdyBjb250YWlucyB0aGUg ZWxlbWVudCwgYmVmb3JlIHdoaWNoIHdlJ2xsIGVucXVldWUgKi8NCiAgICAgbGlzdF9hZGQoRVhU UkFMSVNUKGQsaSksY3VyLT5wcmV2KTsNCiAgDQotICAgIC8qIENvbnRpbnVlIHVwZGF0aW5nIHRo ZSBleHRyYXEuICovDQorICAgIC8qIENvbnRpbnVlIHVwZGF0aW5nIHRoZSBleHRyYXEgKi8NCiAg ICAgaWYgKCAoY3VyICE9IEVYVFJBUShkLT5wcm9jZXNzb3IsaSkpICYmIHN1YiApDQogICAgIHsN CiAgICAgICAgIGZvciAoIGN1ciA9IGN1ci0+bmV4dDsgY3VyICE9IEVYVFJBUShkLT5wcm9jZXNz b3IsaSk7IGN1ciA9IGN1ci0+bmV4dCApDQogICAgICAgICB7DQogICAgICAgICAgICAgY3VyaW5m ID0gbGlzdF9lbnRyeShjdXIsc3RydWN0IHNlZGZfdmNwdV9pbmZvLCBleHRyYWxpc3RbaV0pOw0K ICAgICAgICAgICAgIGN1cmluZi0+c2NvcmVbaV0gLT0gc3ViOw0KLSAgICAgICAgICAgIFBSSU5U KDQsICJcdHVwZGF0aW5nIGRvbWFpbiAlaS4laSAoc2NvcmU9ICV1KVxuIiwNCi0gICAgICAgICAg ICAgICAgICBjdXJpbmYtPnZjcHUtPmRvbWFpbi0+ZG9tYWluX2lkLCANCi0gICAgICAgICAgICAg ICAgICBjdXJpbmYtPnZjcHUtPnZjcHVfaWQsIGN1cmluZi0+c2NvcmVbaV0pOw0KICAgICAgICAg fQ0KICAgICB9DQogDQpAQCAtMjIxLDI5ICsxOTksMTQgQEAgc3RhdGljIGlubGluZSB2b2lkIGV4 dHJhcV9jaGVjayhzdHJ1Y3Qgdg0KIHsNCiAgICAgaWYgKCBleHRyYXFfb24oZCwgRVhUUkFfVVRJ TF9RKSApDQogICAgIHsNCi0gICAgICAgIFBSSU5UKDIsIkRvbSAlaS4laSBpcyBvbiBMMSBleHRy YVFcbiIsDQotICAgICAgICAgICAgICBkLT5kb21haW4tPmRvbWFpbl9pZCwgZC0+dmNwdV9pZCk7 DQotDQogICAgICAgICBpZiAoICEoRURPTV9JTkZPKGQpLT5zdGF0dXMgJiBFWFRSQV9BV0FSRSkg JiYNCiAgICAgICAgICAgICAgIWV4dHJhX3J1bnMoRURPTV9JTkZPKGQpKSApDQotICAgICAgICB7 DQogICAgICAgICAgICAgZXh0cmFxX2RlbChkLCBFWFRSQV9VVElMX1EpOw0KLSAgICAgICAgICAg IFBSSU5UKDIsIlJlbW92ZWQgZG9tICVpLiVpIGZyb20gTDEgZXh0cmFRXG4iLA0KLSAgICAgICAg ICAgICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBkLT52Y3B1X2lkKTsNCi0gICAgICAgIH0N CiAgICAgfQ0KICAgICBlbHNlDQogICAgIHsNCi0gICAgICAgIFBSSU5UKDIsICJEb20gJWkuJWkg aXMgTk9UIG9uIEwxIGV4dHJhUVxuIiwNCi0gICAgICAgICAgICAgIGQtPmRvbWFpbi0+ZG9tYWlu X2lkLA0KLSAgICAgICAgICAgICAgZC0+dmNwdV9pZCk7DQotDQogICAgICAgICBpZiAoIChFRE9N X0lORk8oZCktPnN0YXR1cyAmIEVYVFJBX0FXQVJFKSAmJiBzZWRmX3J1bm5hYmxlKGQpICkNCi0g ICAgICAgIHsNCiAgICAgICAgICAgICBleHRyYXFfYWRkX3NvcnRfdXBkYXRlKGQsIEVYVFJBX1VU SUxfUSwgMCk7DQotICAgICAgICAgICAgUFJJTlQoMiwiQWRkZWQgZG9tICVpLiVpIHRvIEwxIGV4 dHJhUVxuIiwNCi0gICAgICAgICAgICAgICAgICBkLT5kb21haW4tPmRvbWFpbl9pZCwgZC0+dmNw dV9pZCk7DQotICAgICAgICB9DQogICAgIH0NCiB9DQogDQpAQCAtMjUyLDcgKzIxNSw3IEBAIHN0 YXRpYyBpbmxpbmUgdm9pZCBleHRyYXFfY2hlY2tfYWRkX3VuYmwNCiAgICAgc3RydWN0IHNlZGZf dmNwdV9pbmZvICppbmYgPSBFRE9NX0lORk8oZCk7DQogDQogICAgIGlmICggaW5mLT5zdGF0dXMg JiBFWFRSQV9BV0FSRSApDQotICAgICAgICAvKiBQdXQgb24gdGhlIHdlaWdodGVkIGV4dHJhcSB3 aXRob3V0IHVwZGF0aW5nIGFueSBzY29yZXMuICovDQorICAgICAgICAvKiBQdXQgb24gdGhlIHdl aWdodGVkIGV4dHJhcSB3aXRob3V0IHVwZGF0aW5nIGFueSBzY29yZXMgKi8NCiAgICAgICAgIGV4 dHJhcV9hZGRfc29ydF91cGRhdGUoZCwgRVhUUkFfVVRJTF9RLCAwKTsNCiB9DQogDQpAQCAtMjY1 LDggKzIyOCw2IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBfX2RlbF9mcm9tX3F1ZXVlKHN0cnUNCiB7 DQogICAgIHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QgPSBMSVNUKGQpOw0KICAgICBBU1NFUlQoX190 YXNrX29uX3F1ZXVlKGQpKTsNCi0gICAgUFJJTlQoMywiUmVtb3ZpbmcgZG9tYWluICVpLiVpIChi b3A9ICUiUFJJdTY0IikgZnJvbSBydW5xL3dhaXRxXG4iLA0KLSAgICAgICAgICBkLT5kb21haW4t PmRvbWFpbl9pZCwgZC0+dmNwdV9pZCwgUEVSSU9EX0JFR0lOKEVET01fSU5GTyhkKSkpOw0KICAg ICBsaXN0X2RlbChsaXN0KTsNCiAgICAgbGlzdC0+bmV4dCA9IE5VTEw7DQogICAgIEFTU0VSVCgh X190YXNrX29uX3F1ZXVlKGQpKTsNCkBAIC0yNzksMTMgKzI0MCwxMiBAQCBzdGF0aWMgaW5saW5l IHZvaWQgbGlzdF9pbnNlcnRfc29ydCgNCiB7DQogICAgIHN0cnVjdCBsaXN0X2hlYWQgICAgICpj dXI7DQogDQotICAgIC8qIEl0ZXJhdGUgdGhyb3VnaCBhbGwgZWxlbWVudHMgdG8gZmluZCBvdXIg ImhvbGUiLiAqLw0KKyAgICAvKiBJdGVyYXRlIHRocm91Z2ggYWxsIGVsZW1lbnRzIHRvIGZpbmQg b3VyICJob2xlIiAqLw0KICAgICBsaXN0X2Zvcl9lYWNoKCBjdXIsIGxpc3QgKQ0KICAgICAgICAg aWYgKCBjb21wKGVsZW1lbnQsIGN1cikgPCAwICkNCiAgICAgICAgICAgICBicmVhazsNCiANCi0g ICAgLyogY3VyIG5vdyBjb250YWlucyB0aGUgZWxlbWVudCwgYmVmb3JlIHdoaWNoIHdlJ2xsIGVu cXVldWUuICovDQotICAgIFBSSU5UKDMsIlx0bGlzdF9hZGQgdG8gJXBcbiIsY3VyLT5wcmV2KTsN CisgICAgLyogY3VyIG5vdyBjb250YWlucyB0aGUgZWxlbWVudCwgYmVmb3JlIHdoaWNoIHdlJ2xs IGVucXVldWUgKi8NCiAgICAgbGlzdF9hZGQoZWxlbWVudCwgY3VyLT5wcmV2KTsNCiB9DQogDQpA QCAtMzAzLDMwICsyNjMsMjYgQEAgc3RhdGljIGludCBuYW1lIyNfY29tcChzdHJ1Y3QgbGlzdF9o ZWFkKg0KICAgICAgICAgcmV0dXJuIDE7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFwNCiB9DQogDQotLyogYWRkcyBhIGRvbWFpbiB0byB0aGUg cXVldWUgb2YgcHJvY2Vzc2VzIHdoaWNoIHdhaXQgZm9yIHRoZSBiZWdpbm5pbmcgb2YgdGhlDQot ICAgbmV4dCBwZXJpb2Q7IHRoaXMgbGlzdCBpcyB0aGVyZWZvcmUgc29ydGV0IGJ5IHRoaXMgdGlt ZSwgd2hpY2ggaXMgc2ltcGx5DQotICAgYWJzb2wuIGRlYWRsaW5lIC0gcGVyaW9kDQorLyogQWRk cyBhIGRvbWFpbiB0byB0aGUgcXVldWUgb2YgcHJvY2Vzc2VzIHdoaWNoIHdhaXQgZm9yIHRoZSBi ZWdpbm5pbmcgb2YgdGhlDQorICogbmV4dCBwZXJpb2Q7IHRoaXMgbGlzdCBpcyB0aGVyZWZvcmUg c29ydGV0IGJ5IHRoaXMgdGltZSwgd2hpY2ggaXMgc2ltcGx5DQorICogYWJzb2wuIGRlYWRsaW5l IC0gcGVyaW9kLg0KICAqLyANCiBET01BSU5fQ09NUEFSRVIod2FpdHEsIGxpc3QsIFBFUklPRF9C RUdJTihkMSksIFBFUklPRF9CRUdJTihkMikpOw0KIHN0YXRpYyBpbmxpbmUgdm9pZCBfX2FkZF90 b193YWl0cXVldWVfc29ydChzdHJ1Y3QgdmNwdSAqdikNCiB7DQogICAgIEFTU0VSVCghX190YXNr X29uX3F1ZXVlKHYpKTsNCi0gICAgUFJJTlQoMywiQWRkaW5nIGRvbWFpbiAlaS4laSAoYm9wPSAl IlBSSXU2NCIpIHRvIHdhaXRxXG4iLA0KLSAgICAgICAgICB2LT5kb21haW4tPmRvbWFpbl9pZCwg di0+dmNwdV9pZCwgUEVSSU9EX0JFR0lOKEVET01fSU5GTyh2KSkpOw0KICAgICBsaXN0X2luc2Vy dF9zb3J0KFdBSVRRKHYtPnByb2Nlc3NvciksIExJU1QodiksIHdhaXRxX2NvbXApOw0KICAgICBB U1NFUlQoX190YXNrX29uX3F1ZXVlKHYpKTsNCiB9DQogDQotLyogYWRkcyBhIGRvbWFpbiB0byB0 aGUgcXVldWUgb2YgcHJvY2Vzc2VzIHdoaWNoIGhhdmUgc3RhcnRlZCB0aGVpciBjdXJyZW50DQot ICAgcGVyaW9kIGFuZCBhcmUgcnVubmFibGUgKGkuZS4gbm90IGJsb2NrZWQsIGRpZWluZywuLi4p LiBUaGUgZmlyc3QgZWxlbWVudA0KLSAgIG9uIHRoaXMgbGlzdCBpcyBydW5uaW5nIG9uIHRoZSBw cm9jZXNzb3IsIGlmIHRoZSBsaXN0IGlzIGVtcHR5IHRoZSBpZGxlDQotICAgdGFzayB3aWxsIHJ1 bi4gQXMgd2UgYXJlIGltcGxlbWVudGluZyBFREYsIHRoaXMgbGlzdCBpcyBzb3J0ZWQgYnkgZGVh ZGxpbmVzLg0KKy8qIEFkZHMgYSBkb21haW4gdG8gdGhlIHF1ZXVlIG9mIHByb2Nlc3NlcyB3aGlj aCBoYXZlIHN0YXJ0ZWQgdGhlaXIgY3VycmVudA0KKyAqIHBlcmlvZCBhbmQgYXJlIHJ1bm5hYmxl IChpLmUuIG5vdCBibG9ja2VkLCBkaWVpbmcsLi4uKS4gVGhlIGZpcnN0IGVsZW1lbnQNCisgKiBv biB0aGlzIGxpc3QgaXMgcnVubmluZyBvbiB0aGUgcHJvY2Vzc29yLCBpZiB0aGUgbGlzdCBpcyBl bXB0eSB0aGUgaWRsZQ0KKyAqIHRhc2sgd2lsbCBydW4uIEFzIHdlIGFyZSBpbXBsZW1lbnRpbmcg RURGLCB0aGlzIGxpc3QgaXMgc29ydGVkIGJ5IGRlYWRsaW5lcy4NCiAgKi8gDQogRE9NQUlOX0NP TVBBUkVSKHJ1bnEsIGxpc3QsIGQxLT5kZWFkbF9hYnMsIGQyLT5kZWFkbF9hYnMpOw0KIHN0YXRp YyBpbmxpbmUgdm9pZCBfX2FkZF90b19ydW5xdWV1ZV9zb3J0KHN0cnVjdCB2Y3B1ICp2KQ0KIHsN Ci0gICAgUFJJTlQoMywiQWRkaW5nIGRvbWFpbiAlaS4laSAoZGVhZGw9ICUiUFJJdTY0IikgdG8g cnVucVxuIiwNCi0gICAgICAgICAgdi0+ZG9tYWluLT5kb21haW5faWQsIHYtPnZjcHVfaWQsIEVE T01fSU5GTyh2KS0+ZGVhZGxfYWJzKTsNCiAgICAgbGlzdF9pbnNlcnRfc29ydChSVU5RKHYtPnBy b2Nlc3NvciksIExJU1QodiksIHJ1bnFfY29tcCk7DQogfQ0KIA0KQEAgLTQ0NSwyMiArNDAxLDIx IEBAIHN0YXRpYyBpbnQgc2VkZl9waWNrX2NwdShjb25zdCBzdHJ1Y3Qgc2MNCiAgICAgcmV0dXJu IGNwdW1hc2tfZmlyc3QoJm9ubGluZV9hZmZpbml0eSk7DQogfQ0KIA0KLS8qDQotICogSGFuZGxl cyB0aGUgcmVzY2hlZHVsaW5nICYgYm9va2tlZXBpbmcgb2YgZG9tYWlucyBydW5uaW5nIGluIHRo ZWlyDQorDQorLyogSGFuZGxlcyB0aGUgcmVzY2hlZHVsaW5nICYgYm9va2tlZXBpbmcgb2YgZG9t YWlucyBydW5uaW5nIGluIHRoZWlyDQogICogZ3VhcmFudGVlZCB0aW1lc2xpY2UuDQogICovDQog c3RhdGljIHZvaWQgZGVzY2hlZF9lZGZfZG9tKHNfdGltZV90IG5vdywgc3RydWN0IHZjcHUqIGQp DQogew0KICAgICBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8qIGluZiA9IEVET01fSU5GTyhkKTsNCiAN Ci0gICAgLyogQ3VycmVudCBkb21haW4gaXMgcnVubmluZyBpbiByZWFsIHRpbWUgbW9kZS4gKi8N CisgICAgLyogQ3VycmVudCBkb21haW4gaXMgcnVubmluZyBpbiByZWFsIHRpbWUgbW9kZSAqLw0K ICAgICBBU1NFUlQoX190YXNrX29uX3F1ZXVlKGQpKTsNCiANCi0gICAgLyogVXBkYXRlIHRoZSBk b21haW4ncyBjcHV0aW1lLiAqLw0KKyAgICAvKiBVcGRhdGUgdGhlIGRvbWFpbidzIGNwdXRpbWUg Ki8NCiAgICAgaW5mLT5jcHV0aW1lICs9IG5vdyAtIGluZi0+c2NoZWRfc3RhcnRfYWJzOw0KIA0K LSAgICAvKg0KLSAgICAgKiBTY2hlZHVsaW5nIGRlY2lzaW9ucyB3aGljaCBkb24ndCByZW1vdmUg dGhlIHJ1bm5pbmcgZG9tYWluIGZyb20gdGhlDQorICAgIC8qIFNjaGVkdWxpbmcgZGVjaXNpb25z IHdoaWNoIGRvbid0IHJlbW92ZSB0aGUgcnVubmluZyBkb21haW4gZnJvbSB0aGUNCiAgICAgICog cnVucS4gDQogICAgICAqLw0KICAgICBpZiAoIChpbmYtPmNwdXRpbWUgPCBpbmYtPnNsaWNlKSAm JiBzZWRmX3J1bm5hYmxlKGQpICkNCkBAIC00NjgsOCArNDIzLDcgQEAgc3RhdGljIHZvaWQgZGVz Y2hlZF9lZGZfZG9tKHNfdGltZV90IG5vdw0KICAgDQogICAgIF9fZGVsX2Zyb21fcXVldWUoZCk7 DQogICANCi0gICAgLyoNCi0gICAgICogTWFuYWdlIGJvb2trZWVwaW5nIChpLmUuIGNhbGN1bGF0 ZSBuZXh0IGRlYWRsaW5lLCBtZW1vcmlzZQ0KKyAgICAvKiBNYW5hZ2UgYm9va2tlZXBpbmcgKGku ZS4gY2FsY3VsYXRlIG5leHQgZGVhZGxpbmUsIG1lbW9yaXNlDQogICAgICAqIG92ZXJydW4tdGlt ZSBvZiBzbGljZSkgb2YgZmluaXNoZWQgZG9tYWlucy4NCiAgICAgICovDQogICAgIGlmICggaW5m LT5jcHV0aW1lID49IGluZi0+c2xpY2UgKQ0KQEAgLTQ3OCwzMCArNDMyLDMwIEBAIHN0YXRpYyB2 b2lkIGRlc2NoZWRfZWRmX2RvbShzX3RpbWVfdCBub3cNCiAgIA0KICAgICAgICAgaWYgKCBpbmYt PnBlcmlvZCA8IGluZi0+cGVyaW9kX29yaWcgKQ0KICAgICAgICAgew0KLSAgICAgICAgICAgIC8q IFRoaXMgZG9tYWluIHJ1bnMgaW4gbGF0ZW5jeSBzY2FsaW5nIG9yIGJ1cnN0IG1vZGUuICovDQor ICAgICAgICAgICAgLyogVGhpcyBkb21haW4gcnVucyBpbiBsYXRlbmN5IHNjYWxpbmcgb3IgYnVy c3QgbW9kZSAqLw0KICAgICAgICAgICAgIGluZi0+cGVyaW9kICo9IDI7DQogICAgICAgICAgICAg aW5mLT5zbGljZSAgKj0gMjsNCiAgICAgICAgICAgICBpZiAoIChpbmYtPnBlcmlvZCA+IGluZi0+ cGVyaW9kX29yaWcpIHx8DQogICAgICAgICAgICAgICAgICAoaW5mLT5zbGljZSA+IGluZi0+c2xp Y2Vfb3JpZykgKQ0KICAgICAgICAgICAgIHsNCi0gICAgICAgICAgICAgICAgLyogUmVzZXQgc2xp Y2UgYW5kIHBlcmlvZC4gKi8NCisgICAgICAgICAgICAgICAgLyogUmVzZXQgc2xpY2UgYW5kIHBl cmlvZCAqLw0KICAgICAgICAgICAgICAgICBpbmYtPnBlcmlvZCA9IGluZi0+cGVyaW9kX29yaWc7 DQogICAgICAgICAgICAgICAgIGluZi0+c2xpY2UgPSBpbmYtPnNsaWNlX29yaWc7DQogICAgICAg ICAgICAgfQ0KICAgICAgICAgfQ0KIA0KLSAgICAgICAgLyogU2V0IG5leHQgZGVhZGxpbmUuICov DQorICAgICAgICAvKiBTZXQgbmV4dCBkZWFkbGluZSAqLw0KICAgICAgICAgaW5mLT5kZWFkbF9h YnMgKz0gaW5mLT5wZXJpb2Q7DQogICAgIH0NCiAgDQotICAgIC8qIEFkZCBhIHJ1bm5hYmxlIGRv bWFpbiB0byB0aGUgd2FpdHF1ZXVlLiAqLw0KKyAgICAvKiBBZGQgYSBydW5uYWJsZSBkb21haW4g dG8gdGhlIHdhaXRxdWV1ZSAqLw0KICAgICBpZiAoIHNlZGZfcnVubmFibGUoZCkgKQ0KICAgICB7 DQogICAgICAgICBfX2FkZF90b193YWl0cXVldWVfc29ydChkKTsNCiAgICAgfQ0KICAgICBlbHNl DQogICAgIHsNCi0gICAgICAgIC8qIFdlIGhhdmUgYSBibG9ja2VkIHJlYWx0aW1lIHRhc2sgLT4g cmVtb3ZlIGl0IGZyb20gZXhxcyB0b28uICovDQorICAgICAgICAvKiBXZSBoYXZlIGEgYmxvY2tl ZCByZWFsdGltZSB0YXNrIC0+IHJlbW92ZSBpdCBmcm9tIGV4cXMgdG9vICovDQogICAgICAgICBp ZiAoIGV4dHJhcV9vbihkLCBFWFRSQV9QRU5fUSkgKQ0KICAgICAgICAgICAgIGV4dHJhcV9kZWwo ZCwgRVhUUkFfUEVOX1EpOw0KICAgICAgICAgaWYgKCBleHRyYXFfb24oZCwgRVhUUkFfVVRJTF9R KSApDQpAQCAtNTIxLDczICs0NzUsNTkgQEAgc3RhdGljIHZvaWQgdXBkYXRlX3F1ZXVlcygNCiAg ICAgc3RydWN0IGxpc3RfaGVhZCAgICAgKmN1ciwgKnRtcDsNCiAgICAgc3RydWN0IHNlZGZfdmNw dV9pbmZvICpjdXJpbmY7DQogIA0KLSAgICBQUklOVCgzLCJVcGRhdGluZyB3YWl0cS4uXG4iKTsN Ci0NCi0gICAgLyoNCi0gICAgICogQ2hlY2sgZm9yIHRoZSBmaXJzdCBlbGVtZW50cyBvZiB0aGUg d2FpdHF1ZXVlLCB3aGV0aGVyIHRoZWlyDQorICAgIC8qIENoZWNrIGZvciB0aGUgZmlyc3QgZWxl bWVudHMgb2YgdGhlIHdhaXRxdWV1ZSwgd2hldGhlciB0aGVpcg0KICAgICAgKiBuZXh0IHBlcmlv ZCBoYXMgYWxyZWFkeSBzdGFydGVkLg0KICAgICAgKi8NCiAgICAgbGlzdF9mb3JfZWFjaF9zYWZl ICggY3VyLCB0bXAsIHdhaXRxICkNCiAgICAgew0KICAgICAgICAgY3VyaW5mID0gbGlzdF9lbnRy eShjdXIsIHN0cnVjdCBzZWRmX3ZjcHVfaW5mbywgbGlzdCk7DQotICAgICAgICBQUklOVCg0LCJc dExvb2tpbmcgQCBkb20gJWkuJWlcbiIsDQotICAgICAgICAgICAgICBjdXJpbmYtPnZjcHUtPmRv bWFpbi0+ZG9tYWluX2lkLCBjdXJpbmYtPnZjcHUtPnZjcHVfaWQpOw0KICAgICAgICAgaWYgKCBQ RVJJT0RfQkVHSU4oY3VyaW5mKSA+IG5vdyApDQogICAgICAgICAgICAgYnJlYWs7DQogICAgICAg ICBfX2RlbF9mcm9tX3F1ZXVlKGN1cmluZi0+dmNwdSk7DQogICAgICAgICBfX2FkZF90b19ydW5x dWV1ZV9zb3J0KGN1cmluZi0+dmNwdSk7DQogICAgIH0NCiAgDQotICAgIFBSSU5UKDMsIlVwZGF0 aW5nIHJ1bnEuLlxuIik7DQotDQotICAgIC8qIFByb2Nlc3MgdGhlIHJ1bnEsIGZpbmQgZG9tYWlu cyB0aGF0IGFyZSBvbiB0aGUgcnVucSB0aGF0IHNob3VsZG4ndC4gKi8NCisgICAgLyogUHJvY2Vz cyB0aGUgcnVucSwgZmluZCBkb21haW5zIHRoYXQgYXJlIG9uIHRoZSBydW5xIHRoYXQgc2hvdWxk bid0ICovDQogICAgIGxpc3RfZm9yX2VhY2hfc2FmZSAoIGN1ciwgdG1wLCBydW5xICkNCiAgICAg ew0KICAgICAgICAgY3VyaW5mID0gbGlzdF9lbnRyeShjdXIsc3RydWN0IHNlZGZfdmNwdV9pbmZv LGxpc3QpOw0KLSAgICAgICAgUFJJTlQoNCwiXHRMb29raW5nIEAgZG9tICVpLiVpXG4iLA0KLSAg ICAgICAgICAgICAgY3VyaW5mLT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwgY3VyaW5mLT52Y3B1 LT52Y3B1X2lkKTsNCiANCiAgICAgICAgIGlmICggdW5saWtlbHkoY3VyaW5mLT5zbGljZSA9PSAw KSApDQogICAgICAgICB7DQotICAgICAgICAgICAgLyogSWdub3JlIGRvbWFpbnMgd2l0aCBlbXB0 eSBzbGljZS4gKi8NCi0gICAgICAgICAgICBQUklOVCg0LCJcdFVwZGF0aW5nIHplcm8tc2xpY2Ug ZG9tYWluICVpLiVpXG4iLA0KLSAgICAgICAgICAgICAgICAgIGN1cmluZi0+dmNwdS0+ZG9tYWlu LT5kb21haW5faWQsDQotICAgICAgICAgICAgICAgICAgY3VyaW5mLT52Y3B1LT52Y3B1X2lkKTsN CisgICAgICAgICAgICAvKiBJZ25vcmUgZG9tYWlucyB3aXRoIGVtcHR5IHNsaWNlICovDQogICAg ICAgICAgICAgX19kZWxfZnJvbV9xdWV1ZShjdXJpbmYtPnZjcHUpOw0KIA0KLSAgICAgICAgICAg IC8qIE1vdmUgdGhlbSB0byB0aGVpciBuZXh0IHBlcmlvZC4gKi8NCisgICAgICAgICAgICAvKiBN b3ZlIHRoZW0gdG8gdGhlaXIgbmV4dCBwZXJpb2QgKi8NCiAgICAgICAgICAgICBjdXJpbmYtPmRl YWRsX2FicyArPSBjdXJpbmYtPnBlcmlvZDsNCiANCi0gICAgICAgICAgICAvKiBFbnN1cmUgdGhh dCB0aGUgc3RhcnQgb2YgdGhlIG5leHQgcGVyaW9kIGlzIGluIHRoZSBmdXR1cmUuICovDQorICAg ICAgICAgICAgLyogRW5zdXJlIHRoYXQgdGhlIHN0YXJ0IG9mIHRoZSBuZXh0IHBlcmlvZCBpcyBp biB0aGUgZnV0dXJlICovDQogICAgICAgICAgICAgaWYgKCB1bmxpa2VseShQRVJJT0RfQkVHSU4o Y3VyaW5mKSA8IG5vdykgKQ0KICAgICAgICAgICAgICAgICBjdXJpbmYtPmRlYWRsX2FicyArPSAN CiAgICAgICAgICAgICAgICAgICAgIChESVZfVVAobm93IC0gUEVSSU9EX0JFR0lOKGN1cmluZiks DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGN1cmluZi0+cGVyaW9kKSkgKiBjdXJpbmYt PnBlcmlvZDsNCiANCi0gICAgICAgICAgICAvKiBQdXQgdGhlbSBiYWNrIGludG8gdGhlIHF1ZXVl LiAqLw0KKyAgICAgICAgICAgIC8qIFB1dCB0aGVtIGJhY2sgaW50byB0aGUgcXVldWUgKi8NCiAg ICAgICAgICAgICBfX2FkZF90b193YWl0cXVldWVfc29ydChjdXJpbmYtPnZjcHUpOw0KICAgICAg ICAgfQ0KICAgICAgICAgZWxzZSBpZiAoIHVubGlrZWx5KChjdXJpbmYtPmRlYWRsX2FicyA8IG5v dykgfHwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAoY3VyaW5mLT5jcHV0aW1lID4gY3Vy aW5mLT5zbGljZSkpICkNCiAgICAgICAgIHsNCi0gICAgICAgICAgICAvKg0KLSAgICAgICAgICAg ICAqIFdlIG1pc3NlZCB0aGUgZGVhZGxpbmUgb3IgdGhlIHNsaWNlIHdhcyBhbHJlYWR5IGZpbmlz aGVkLg0KKyAgICAgICAgICAgIC8qIFdlIG1pc3NlZCB0aGUgZGVhZGxpbmUgb3IgdGhlIHNsaWNl IHdhcyBhbHJlYWR5IGZpbmlzaGVkLg0KICAgICAgICAgICAgICAqIE1pZ2h0IGhhcGVuIGJlY2F1 c2Ugb2YgZG9tX2Fkai4NCiAgICAgICAgICAgICAgKi8NCi0gICAgICAgICAgICBQUklOVCg0LCJc dERvbWFpbiAlaS4laSBleGNlZWRlZCBpdCdzIGRlYWRsaW5lLyINCi0gICAgICAgICAgICAgICAg ICAic2xpY2UgKCUiUFJJdTY0IiAvICUiUFJJdTY0Iikgbm93OiAlIlBSSXU2NA0KLSAgICAgICAg ICAgICAgICAgICIgY3B1dGltZTogJSJQUkl1NjQiXG4iLA0KLSAgICAgICAgICAgICAgICAgIGN1 cmluZi0+dmNwdS0+ZG9tYWluLT5kb21haW5faWQsDQotICAgICAgICAgICAgICAgICAgY3VyaW5m LT52Y3B1LT52Y3B1X2lkLA0KLSAgICAgICAgICAgICAgICAgIGN1cmluZi0+ZGVhZGxfYWJzLCBj dXJpbmYtPnNsaWNlLCBub3csDQotICAgICAgICAgICAgICAgICAgY3VyaW5mLT5jcHV0aW1lKTsN CisgICAgICAgICAgICBwcmludGsoIlx0RG9tYWluICVpLiVpIGV4Y2VlZGVkIGl0J3MgZGVhZGxp bmUvIg0KKyAgICAgICAgICAgICAgICAgICAic2xpY2UgKCUiUFJJdTY0IiAvICUiUFJJdTY0Iikg bm93OiAlIlBSSXU2NA0KKyAgICAgICAgICAgICAgICAgICAiIGNwdXRpbWU6ICUiUFJJdTY0Ilxu IiwNCisgICAgICAgICAgICAgICAgICAgY3VyaW5mLT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwN CisgICAgICAgICAgICAgICAgICAgY3VyaW5mLT52Y3B1LT52Y3B1X2lkLA0KKyAgICAgICAgICAg ICAgICAgICBjdXJpbmYtPmRlYWRsX2FicywgY3VyaW5mLT5zbGljZSwgbm93LA0KKyAgICAgICAg ICAgICAgICAgICBjdXJpbmYtPmNwdXRpbWUpOw0KICAgICAgICAgICAgIF9fZGVsX2Zyb21fcXVl dWUoY3VyaW5mLT52Y3B1KTsNCiANCi0gICAgICAgICAgICAvKiBDb21tb24gY2FzZTogd2UgbWlz cyBvbmUgcGVyaW9kLiAqLw0KKyAgICAgICAgICAgIC8qIENvbW1vbiBjYXNlOiB3ZSBtaXNzIG9u ZSBwZXJpb2QgKi8NCiAgICAgICAgICAgICBjdXJpbmYtPmRlYWRsX2FicyArPSBjdXJpbmYtPnBl cmlvZDsNCiAgICANCi0gICAgICAgICAgICAvKg0KLSAgICAgICAgICAgICAqIElmIHdlIGFyZSBz dGlsbCBiZWhpbmQ6IG1vZHVsbyBhcml0aG1ldGljLCBmb3JjZSBkZWFkbGluZQ0KKyAgICAgICAg ICAgIC8qIElmIHdlIGFyZSBzdGlsbCBiZWhpbmQ6IG1vZHVsbyBhcml0aG1ldGljLCBmb3JjZSBk ZWFkbGluZQ0KICAgICAgICAgICAgICAqIHRvIGJlIGluIGZ1dHVyZSBhbmQgYWxpZ25lZCB0byBw ZXJpb2QgYm9yZGVycy4NCiAgICAgICAgICAgICAgKi8NCiAgICAgICAgICAgICBpZiAoIHVubGlr ZWx5KGN1cmluZi0+ZGVhZGxfYWJzIDwgbm93KSApDQpAQCAtNTk2LDcgKzUzNiw3IEBAIHN0YXRp YyB2b2lkIHVwZGF0ZV9xdWV1ZXMoDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgY3VyaW5m LT5wZXJpb2QpICogY3VyaW5mLT5wZXJpb2Q7DQogICAgICAgICAgICAgQVNTRVJUKGN1cmluZi0+ ZGVhZGxfYWJzID49IG5vdyk7DQogDQotICAgICAgICAgICAgLyogR2l2ZSBhIGZyZXNoIHNsaWNl LiAqLw0KKyAgICAgICAgICAgIC8qIEdpdmUgYSBmcmVzaCBzbGljZSAqLw0KICAgICAgICAgICAg IGN1cmluZi0+Y3B1dGltZSA9IDA7DQogICAgICAgICAgICAgaWYgKCBQRVJJT0RfQkVHSU4oY3Vy aW5mKSA+IG5vdyApDQogICAgICAgICAgICAgICAgIF9fYWRkX3RvX3dhaXRxdWV1ZV9zb3J0KGN1 cmluZi0+dmNwdSk7DQpAQCAtNjA2LDE3ICs1NDYsMTYgQEAgc3RhdGljIHZvaWQgdXBkYXRlX3F1 ZXVlcygNCiAgICAgICAgIGVsc2UNCiAgICAgICAgICAgICBicmVhazsNCiAgICAgfQ0KLQ0KLSAg ICBQUklOVCgzLCJkb25lIHVwZGF0aW5nIHRoZSBxdWV1ZXNcbiIpOw0KIH0NCiANCiANCiAvKiBy ZW1vdmVzIGEgZG9tYWluIGZyb20gdGhlIGhlYWQgb2YgdGhlIGFjY29yZGluZyBleHRyYVEgYW5k DQotICAgcmVxdWV1ZXMgaXQgYXQgYSBzcGVjaWZpZWQgcG9zaXRpb246DQotICAgICByb3VuZC1y b2JpbiBleHRyYXRpbWU6IGVuZCBvZiBleHRyYVENCi0gICAgIHdlaWdodGVkIGV4dC46IGluc2Vy dCBpbiBzb3J0ZWQgbGlzdCBieSBzY29yZQ0KLSAgIGlmIHRoZSBkb21haW4gaXMgYmxvY2tlZCAv IGhhcyByZWdhaW5lZCBpdHMgc2hvcnQtYmxvY2stbG9zcw0KLSAgIHRpbWUgaXQgaXMgbm90IHB1 dCBvbiBhbnkgcXVldWUgKi8NCisgKiByZXF1ZXVlcyBpdCBhdCBhIHNwZWNpZmllZCBwb3NpdGlv bjoNCisgKiAgIHJvdW5kLXJvYmluIGV4dHJhdGltZTogZW5kIG9mIGV4dHJhUQ0KKyAqICAgd2Vp Z2h0ZWQgZXh0LjogaW5zZXJ0IGluIHNvcnRlZCBsaXN0IGJ5IHNjb3JlDQorICogaWYgdGhlIGRv bWFpbiBpcyBibG9ja2VkIC8gaGFzIHJlZ2FpbmVkIGl0cyBzaG9ydC1ibG9jay1sb3NzDQorICog dGltZSBpdCBpcyBub3QgcHV0IG9uIGFueSBxdWV1ZS4NCisgKi8NCiBzdGF0aWMgdm9pZCBkZXNj aGVkX2V4dHJhX2RvbShzX3RpbWVfdCBub3csIHN0cnVjdCB2Y3B1ICpkKQ0KIHsNCiAgICAgc3Ry dWN0IHNlZGZfdmNwdV9pbmZvICppbmYgPSBFRE9NX0lORk8oZCk7DQpAQCAtNjI1LDI5ICs1NjQs MjUgQEAgc3RhdGljIHZvaWQgZGVzY2hlZF9leHRyYV9kb20oc190aW1lX3Qgbg0KIA0KICAgICBB U1NFUlQoZXh0cmFxX29uKGQsIGkpKTsNCiANCi0gICAgLyogVW5zZXQgYWxsIHJ1bm5pbmcgZmxh Z3MuICovDQorICAgIC8qIFVuc2V0IGFsbCBydW5uaW5nIGZsYWdzICovDQogICAgIGluZi0+c3Rh dHVzICAmPSB+KEVYVFJBX1JVTl9QRU4gfCBFWFRSQV9SVU5fVVRJTCk7DQotICAgIC8qIEZyZXNo IHNsaWNlIGZvciB0aGUgbmV4dCBydW4uICovDQorICAgIC8qIEZyZXNoIHNsaWNlIGZvciB0aGUg bmV4dCBydW4gKi8NCiAgICAgaW5mLT5jcHV0aW1lID0gMDsNCi0gICAgLyogQWNjdW11bGF0ZSB0 b3RhbCBleHRyYXRpbWUuICovDQorICAgIC8qIEFjY3VtdWxhdGUgdG90YWwgZXh0cmF0aW1lICov DQogICAgIGluZi0+ZXh0cmFfdGltZV90b3QgKz0gbm93IC0gaW5mLT5zY2hlZF9zdGFydF9hYnM7 DQogICAgIC8qIFJlbW92ZSBleHRyYWRvbWFpbiBmcm9tIGhlYWQgb2YgdGhlIHF1ZXVlLiAqLw0K ICAgICBleHRyYXFfZGVsKGQsIGkpOw0KIA0KLSAgICAvKiBVcGRhdGUgdGhlIHNjb3JlLiAqLw0K KyAgICAvKiBVcGRhdGUgdGhlIHNjb3JlICovDQogICAgIG9sZHNjb3JlID0gaW5mLT5zY29yZVtp XTsNCiAgICAgaWYgKCBpID09IEVYVFJBX1BFTl9RICkNCiAgICAgew0KLSAgICAgICAgLypkb21h aW4gd2FzIHJ1bm5pbmcgaW4gTDAgZXh0cmFxKi8NCi0gICAgICAgIC8qcmVkdWNlIGJsb2NrIGxv c3QsIHByb2JhYmx5IG1vcmUgc29waGlzdGljYXRpb24gaGVyZSEqLw0KKyAgICAgICAgLyogRG9t YWluIHdhcyBydW5uaW5nIGluIEwwIGV4dHJhcSAqLw0KKyAgICAgICAgLyogcmVkdWNlIGJsb2Nr IGxvc3QsIHByb2JhYmx5IG1vcmUgc29waGlzdGljYXRpb24gaGVyZSEqLw0KICAgICAgICAgLypp bmYtPnNob3J0X2Jsb2NrX2xvc3RfdG90IC09IEVYVFJBX1FVQU5UVU07Ki8NCiAgICAgICAgIGlu Zi0+c2hvcnRfYmxvY2tfbG9zdF90b3QgLT0gbm93IC0gaW5mLT5zY2hlZF9zdGFydF9hYnM7DQot ICAgICAgICBQUklOVCgzLCJEb21haW4gJWkuJWk6IFNob3J0X2Jsb2NrX2xvc3M6ICUiUFJJaTY0 IlxuIiwgDQotICAgICAgICAgICAgICBpbmYtPnZjcHUtPmRvbWFpbi0+ZG9tYWluX2lkLCBpbmYt PnZjcHUtPnZjcHVfaWQsDQotICAgICAgICAgICAgICBpbmYtPnNob3J0X2Jsb2NrX2xvc3RfdG90 KTsNCiAjaWYgMA0KLSAgICAgICAgLyoNCi0gICAgICAgICAqIEtBRjogSWYgd2UgZG9uJ3QgZXhp dCBzaG9ydC1ibG9ja2luZyBzdGF0ZSBhdCB0aGlzIHBvaW50DQorICAgICAgICAvKiBLQUY6IElm IHdlIGRvbid0IGV4aXQgc2hvcnQtYmxvY2tpbmcgc3RhdGUgYXQgdGhpcyBwb2ludA0KICAgICAg ICAgICogZG9tYWluMCBjYW4gc3RlYWwgYWxsIENQVSBmb3IgdXAgdG8gMTAgc2Vjb25kcyBiZWZv cmUNCiAgICAgICAgICAqIHNjaGVkdWxpbmcgc2V0dGxlcyBkb3duICh3aGVuIGNvbXBldGluZyBh Z2FpbnN0IGFub3RoZXINCiAgICAgICAgICAqIENQVS1ib3VuZCBkb21haW4pLiBEb2luZyB0aGlz IHNlZW1zIHRvIG1ha2UgdGhpbmdzIGJlaGF2ZQ0KQEAgLTY1Niw1MSArNTkxLDU2IEBAIHN0YXRp YyB2b2lkIGRlc2NoZWRfZXh0cmFfZG9tKHNfdGltZV90IG4NCiAgICAgICAgIGlmICggaW5mLT5z aG9ydF9ibG9ja19sb3N0X3RvdCA8PSAwICkNCiAjZW5kaWYNCiAgICAgICAgIHsNCi0gICAgICAg ICAgICBQUklOVCg0LCJEb21haW4gJWkuJWkgY29tcGVuc2F0ZWQgc2hvcnQgYmxvY2sgbG9zcyFc biIsDQotICAgICAgICAgICAgICAgICAgaW5mLT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwgaW5m LT52Y3B1LT52Y3B1X2lkKTsNCi0gICAgICAgICAgICAvKndlIGhhdmUgKG92ZXItKWNvbXBlbnNh dGVkIG91ciBibG9jayBwZW5hbHR5Ki8NCisgICAgICAgICAgICAvKiBXZSBoYXZlIChvdmVyLSlj b21wZW5zYXRlZCBvdXIgYmxvY2sgcGVuYWx0eSAqLw0KICAgICAgICAgICAgIGluZi0+c2hvcnRf YmxvY2tfbG9zdF90b3QgPSAwOw0KLSAgICAgICAgICAgIC8qd2UgZG9uJ3Qgd2FudCBhIHBsYWNl IG9uIHRoZSBwZW5hbHR5IHF1ZXVlIGFueW1vcmUhKi8NCisgICAgICAgICAgICAvKiBXZSBkb24n dCB3YW50IGEgcGxhY2Ugb24gdGhlIHBlbmFsdHkgcXVldWUgYW55bW9yZSEgKi8NCiAgICAgICAg ICAgICBpbmYtPnN0YXR1cyAmPSB+RVhUUkFfV0FOVF9QRU5fUTsNCiAgICAgICAgICAgICBnb3Rv IGNoZWNrX2V4dHJhX3F1ZXVlczsNCiAgICAgICAgIH0NCiANCi0gICAgICAgIC8qd2UgaGF2ZSB0 byBnbyBhZ2FpbiBmb3IgYW5vdGhlciB0cnkgaW4gdGhlIGJsb2NrLWV4dHJhcSwNCi0gICAgICAg ICAgdGhlIHNjb3JlIGlzIG5vdCB1c2VkIGluY3JlbWFudGFsbHkgaGVyZSwgYXMgdGhpcyBpcw0K LSAgICAgICAgICBhbHJlYWR5IGRvbmUgYnkgcmVjYWxjdWxhdGluZyB0aGUgYmxvY2tfbG9zdCov DQorICAgICAgICAvKiBXZSBoYXZlIHRvIGdvIGFnYWluIGZvciBhbm90aGVyIHRyeSBpbiB0aGUg YmxvY2stZXh0cmFxLA0KKyAgICAgICAgICogdGhlIHNjb3JlIGlzIG5vdCB1c2VkIGluY3JlbWFu dGFsbHkgaGVyZSwgYXMgdGhpcyBpcw0KKyAgICAgICAgICogYWxyZWFkeSBkb25lIGJ5IHJlY2Fs Y3VsYXRpbmcgdGhlIGJsb2NrX2xvc3QNCisgICAgICAgICAqLw0KICAgICAgICAgaW5mLT5zY29y ZVtFWFRSQV9QRU5fUV0gPSAoaW5mLT5wZXJpb2QgPDwgMTApIC8NCiAgICAgICAgICAgICBpbmYt PnNob3J0X2Jsb2NrX2xvc3RfdG90Ow0KICAgICAgICAgb2xkc2NvcmUgPSAwOw0KICAgICB9DQog ICAgIGVsc2UNCiAgICAgew0KLSAgICAgICAgLypkb21haW4gd2FzIHJ1bm5pbmcgaW4gTDEgZXh0 cmFxID0+IHNjb3JlIGlzIGludmVyc2Ugb2YNCi0gICAgICAgICAgdXRpbGl6YXRpb24gYW5kIGlz IHVzZWQgc29tZXdoYXQgaW5jcmVtZW50YWwhKi8NCisgICAgICAgIC8qIERvbWFpbiB3YXMgcnVu bmluZyBpbiBMMSBleHRyYXEgPT4gc2NvcmUgaXMgaW52ZXJzZSBvZg0KKyAgICAgICAgICogdXRp bGl6YXRpb24gYW5kIGlzIHVzZWQgc29tZXdoYXQgaW5jcmVtZW50YWwhDQorICAgICAgICAgKi8N CiAgICAgICAgIGlmICggIWluZi0+ZXh0cmF3ZWlnaHQgKQ0KLSAgICAgICAgICAgIC8qTkI6IHVz ZSBmaXhlZCBwb2ludCBhcml0aG1ldGljIHdpdGggMTAgYml0cyovDQorICAgICAgICB7DQorICAg ICAgICAgICAgLyogTkI6IHVzZSBmaXhlZCBwb2ludCBhcml0aG1ldGljIHdpdGggMTAgYml0cyAq Lw0KICAgICAgICAgICAgIGluZi0+c2NvcmVbRVhUUkFfVVRJTF9RXSA9IChpbmYtPnBlcmlvZCA8 PCAxMCkgLw0KICAgICAgICAgICAgICAgICBpbmYtPnNsaWNlOw0KKyAgICAgICAgfQ0KICAgICAg ICAgZWxzZQ0KLSAgICAgICAgICAgIC8qY29udmVyc2lvbiBiZXR3ZWVuIHJlYWx0aW1lIHV0aWxp c2F0aW9uIGFuZCBleHRyYXdpZWdodDoNCi0gICAgICAgICAgICAgIGZ1bGwgKGllIDEwMCUpIHV0 aWxpemF0aW9uIGlzIGVxdWl2YWxlbnQgdG8gMTI4IGV4dHJhd2VpZ2h0Ki8NCisgICAgICAgIHsN CisgICAgICAgICAgICAvKiBDb252ZXJzaW9uIGJldHdlZW4gcmVhbHRpbWUgdXRpbGlzYXRpb24g YW5kIGV4dHJhd2llZ2h0Og0KKyAgICAgICAgICAgICAqIGZ1bGwgKGllIDEwMCUpIHV0aWxpemF0 aW9uIGlzIGVxdWl2YWxlbnQgdG8gMTI4IGV4dHJhd2VpZ2h0DQorICAgICAgICAgICAgICovDQog ICAgICAgICAgICAgaW5mLT5zY29yZVtFWFRSQV9VVElMX1FdID0gKDE8PDE3KSAvIGluZi0+ZXh0 cmF3ZWlnaHQ7DQorICAgICAgICB9DQogICAgIH0NCiANCiAgY2hlY2tfZXh0cmFfcXVldWVzOg0K LSAgICAvKiBBZGRpbmcgYSBydW5uYWJsZSBkb21haW4gdG8gdGhlIHJpZ2h0IHF1ZXVlIGFuZCBy ZW1vdmluZyBibG9ja2VkIG9uZXMqLw0KKyAgICAvKiBBZGRpbmcgYSBydW5uYWJsZSBkb21haW4g dG8gdGhlIHJpZ2h0IHF1ZXVlIGFuZCByZW1vdmluZyBibG9ja2VkIG9uZXMgKi8NCiAgICAgaWYg KCBzZWRmX3J1bm5hYmxlKGQpICkNCiAgICAgew0KLSAgICAgICAgLyphZGQgYWNjb3JkaW5nIHRv IHNjb3JlOiB3ZWlnaHRlZCByb3VuZCByb2JpbiovDQorICAgICAgICAvKiBBZGQgYWNjb3JkaW5n IHRvIHNjb3JlOiB3ZWlnaHRlZCByb3VuZCByb2JpbiAqLw0KICAgICAgICAgaWYgKCgoaW5mLT5z dGF0dXMgJiBFWFRSQV9BV0FSRSkgJiYgKGkgPT0gRVhUUkFfVVRJTF9RKSkgfHwNCiAgICAgICAg ICAgICAoKGluZi0+c3RhdHVzICYgRVhUUkFfV0FOVF9QRU5fUSkgJiYgKGkgPT0gRVhUUkFfUEVO X1EpKSkNCiAgICAgICAgICAgICBleHRyYXFfYWRkX3NvcnRfdXBkYXRlKGQsIGksIG9sZHNjb3Jl KTsNCiAgICAgfQ0KICAgICBlbHNlDQogICAgIHsNCi0gICAgICAgIC8qcmVtb3ZlIHRoaXMgYmxv Y2tlZCBkb21haW4gZnJvbSB0aGUgd2FpdHEhKi8NCisgICAgICAgIC8qIFJlbW92ZSB0aGlzIGJs b2NrZWQgZG9tYWluIGZyb20gdGhlIHdhaXRxISAqLw0KICAgICAgICAgX19kZWxfZnJvbV9xdWV1 ZShkKTsNCi0gICAgICAgIC8qbWFrZSBzdXJlIHRoYXQgd2UgcmVtb3ZlIGEgYmxvY2tlZCBkb21h aW4gZnJvbSB0aGUgb3RoZXINCi0gICAgICAgICAgZXh0cmFxIHRvbyovDQorICAgICAgICAvKiBN YWtlIHN1cmUgdGhhdCB3ZSByZW1vdmUgYSBibG9ja2VkIGRvbWFpbiBmcm9tIHRoZSBvdGhlcg0K KyAgICAgICAgICogZXh0cmFxIHRvby4gKi8NCiAgICAgICAgIGlmICggaSA9PSBFWFRSQV9QRU5f USApDQogICAgICAgICB7DQogICAgICAgICAgICAgaWYgKCBleHRyYXFfb24oZCwgRVhUUkFfVVRJ TF9RKSApDQpAQCAtNzMyLDggKzY3Miw5IEBAIHN0YXRpYyBzdHJ1Y3QgdGFza19zbGljZSBzZWRm X2RvX2V4dHJhX3MNCiANCiAgICAgaWYgKCAhbGlzdF9lbXB0eShleHRyYXFbRVhUUkFfUEVOX1Fd KSApDQogICAgIHsNCi0gICAgICAgIC8qd2Ugc3RpbGwgaGF2ZSBlbGVtZW50cyBvbiB0aGUgbGV2 ZWwgMCBleHRyYXEgDQotICAgICAgICAgID0+IGxldCB0aG9zZSBydW4gZmlyc3QhKi8NCisgICAg ICAgIC8qIFdlIHN0aWxsIGhhdmUgZWxlbWVudHMgb24gdGhlIGxldmVsIDAgZXh0cmFxDQorICAg ICAgICAgKiA9PiBsZXQgdGhvc2UgcnVuIGZpcnN0IQ0KKyAgICAgICAgICovDQogICAgICAgICBy dW5pbmYgICA9IGxpc3RfZW50cnkoZXh0cmFxW0VYVFJBX1BFTl9RXS0+bmV4dCwgDQogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHNlZGZfdmNwdV9pbmZvLCBleHRyYWxpc3Rb RVhUUkFfUEVOX1FdKTsNCiAgICAgICAgIHJ1bmluZi0+c3RhdHVzIHw9IEVYVFJBX1JVTl9QRU47 DQpAQCAtNzQ3LDcgKzY4OCw3IEBAIHN0YXRpYyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX2V4 dHJhX3MNCiAgICAgew0KICAgICAgICAgaWYgKCAhbGlzdF9lbXB0eShleHRyYXFbRVhUUkFfVVRJ TF9RXSkgKQ0KICAgICAgICAgew0KLSAgICAgICAgICAgIC8qdXNlIGVsZW1lbnRzIGZyb20gdGhl IG5vcm1hbCBleHRyYXF1ZXVlKi8NCisgICAgICAgICAgICAvKiBVc2UgZWxlbWVudHMgZnJvbSB0 aGUgbm9ybWFsIGV4dHJhcXVldWUgKi8NCiAgICAgICAgICAgICBydW5pbmYgICA9IGxpc3RfZW50 cnkoZXh0cmFxW0VYVFJBX1VUSUxfUV0tPm5leHQsDQogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHN0cnVjdCBzZWRmX3ZjcHVfaW5mbywNCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZXh0cmFsaXN0W0VYVFJBX1VUSUxfUV0pOw0KQEAgLTc3MywxMCArNzE0LDEx IEBAIHN0YXRpYyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX2V4dHJhX3MNCiANCiANCiAvKiBN YWluIHNjaGVkdWxpbmcgZnVuY3Rpb24NCi0gICBSZWFzb25zIGZvciBjYWxsaW5nIHRoaXMgZnVu Y3Rpb24gYXJlOg0KLSAgIC10aW1lc2xpY2UgZm9yIHRoZSBjdXJyZW50IHBlcmlvZCB1c2VkIHVw DQotICAgLWRvbWFpbiBvbiB3YWl0cXVldWUgaGFzIHN0YXJ0ZWQgaXQncyBwZXJpb2QNCi0gICAt YW5kIHZhcmlvdXMgb3RoZXJzIDspIGluIGdlbmVyYWw6IGRldGVybWluZSB3aGljaCBkb21haW4g dG8gcnVuIG5leHQqLw0KKyAqIFJlYXNvbnMgZm9yIGNhbGxpbmcgdGhpcyBmdW5jdGlvbiBhcmU6 DQorICogLXRpbWVzbGljZSBmb3IgdGhlIGN1cnJlbnQgcGVyaW9kIHVzZWQgdXANCisgKiAtZG9t YWluIG9uIHdhaXRxdWV1ZSBoYXMgc3RhcnRlZCBpdCdzIHBlcmlvZA0KKyAqIC1hbmQgdmFyaW91 cyBvdGhlcnMgOykgaW4gZ2VuZXJhbDogZGV0ZXJtaW5lIHdoaWNoIGRvbWFpbiB0byBydW4gbmV4 dA0KKyAqLw0KIHN0YXRpYyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX3NjaGVkdWxlKA0KICAg ICBjb25zdCBzdHJ1Y3Qgc2NoZWR1bGVyICpvcHMsIHNfdGltZV90IG5vdywgYm9vbF90IHRhc2ts ZXRfd29ya19zY2hlZHVsZWQpDQogew0KQEAgLTc4OSwxMyArNzMxLDE0IEBAIHN0YXRpYyBzdHJ1 Y3QgdGFza19zbGljZSBzZWRmX2RvX3NjaGVkdWwNCiAgICAgc3RydWN0IHNlZGZfdmNwdV9pbmZv ICpydW5pbmYsICp3YWl0aW5mOw0KICAgICBzdHJ1Y3QgdGFza19zbGljZSAgICAgIHJldDsNCiAN Ci0gICAgLyppZGxlIHRhc2tzIGRvbid0IG5lZWQgYW55IG9mIHRoZSBmb2xsb3dpbmcgc3R1Ziov DQorICAgIC8qIElkbGUgdGFza3MgZG9uJ3QgbmVlZCBhbnkgb2YgdGhlIGZvbGxvd2luZyBzdHVm ICovDQogICAgIGlmICggaXNfaWRsZV92Y3B1KGN1cnJlbnQpICkNCiAgICAgICAgIGdvdG8gY2hl Y2tfd2FpdHE7DQogIA0KLSAgICAvKiBjcmVhdGUgbG9jYWwgc3RhdGUgb2YgdGhlIHN0YXR1cyBv ZiB0aGUgZG9tYWluLCBpbiBvcmRlciB0byBhdm9pZA0KLSAgICAgICBpbmNvbnNpc3RlbnQgc3Rh dGUgZHVyaW5nIHNjaGVkdWxpbmcgZGVjaXNpb25zLCBiZWNhdXNlIGRhdGEgZm9yDQotICAgICAg IHZjcHVfcnVubmFibGUgaXMgbm90IHByb3RlY3RlZCBieSB0aGUgc2NoZWR1bGluZyBsb2NrISov DQorICAgIC8qIENyZWF0ZSBsb2NhbCBzdGF0ZSBvZiB0aGUgc3RhdHVzIG9mIHRoZSBkb21haW4s IGluIG9yZGVyIHRvIGF2b2lkDQorICAgICAqIGluY29uc2lzdGVudCBzdGF0ZSBkdXJpbmcgc2No ZWR1bGluZyBkZWNpc2lvbnMsIGJlY2F1c2UgZGF0YSBmb3INCisgICAgICogdmNwdV9ydW5uYWJs ZSBpcyBub3QgcHJvdGVjdGVkIGJ5IHRoZSBzY2hlZHVsaW5nIGxvY2shDQorICAgICAqLw0KICAg ICBpZiAoICF2Y3B1X3J1bm5hYmxlKGN1cnJlbnQpICkNCiAgICAgICAgIGluZi0+c3RhdHVzIHw9 IFNFREZfQVNMRUVQOw0KICANCkBAIC04MDQsNyArNzQ3LDcgQEAgc3RhdGljIHN0cnVjdCB0YXNr X3NsaWNlIHNlZGZfZG9fc2NoZWR1bA0KIA0KICAgICBpZiAoIHVubGlrZWx5KGV4dHJhX3J1bnMo aW5mKSkgKQ0KICAgICB7DQotICAgICAgICAvKnNwZWNpYWwgdHJlYXRtZW50IG9mIGRvbWFpbnMg cnVubmluZyBpbiBleHRyYSB0aW1lKi8NCisgICAgICAgIC8qIFNwZWNpYWwgdHJlYXRtZW50IG9m IGRvbWFpbnMgcnVubmluZyBpbiBleHRyYSB0aW1lICovDQogICAgICAgICBkZXNjaGVkX2V4dHJh X2RvbShub3csIGN1cnJlbnQpOw0KICAgICB9DQogICAgIGVsc2UgDQpAQCAtODE0LDEwICs3NTcs MTEgQEAgc3RhdGljIHN0cnVjdCB0YXNrX3NsaWNlIHNlZGZfZG9fc2NoZWR1bA0KICBjaGVja193 YWl0cToNCiAgICAgdXBkYXRlX3F1ZXVlcyhub3csIHJ1bnEsIHdhaXRxKTsNCiANCi0gICAgLypu b3cgc2ltcGx5IHBpY2sgdGhlIGZpcnN0IGRvbWFpbiBmcm9tIHRoZSBydW5xdWV1ZSwgd2hpY2gg aGFzIHRoZQ0KLSAgICAgIGVhcmxpZXN0IGRlYWRsaW5lLCBiZWNhdXNlIHRoZSBsaXN0IGlzIHNv cnRlZCovDQotIA0KLSAgICAvKiBUYXNrbGV0IHdvcmsgKHdoaWNoIHJ1bnMgaW4gaWRsZSBWQ1BV IGNvbnRleHQpIG92ZXJyaWRlcyBhbGwgZWxzZS4gKi8NCisgICAgLyogTm93IHNpbXBseSBwaWNr IHRoZSBmaXJzdCBkb21haW4gZnJvbSB0aGUgcnVucXVldWUsIHdoaWNoIGhhcyB0aGUNCisgICAg ICogZWFybGllc3QgZGVhZGxpbmUsIGJlY2F1c2UgdGhlIGxpc3QgaXMgc29ydGVkDQorICAgICAq DQorICAgICAqIFRhc2tsZXQgd29yayAod2hpY2ggcnVucyBpbiBpZGxlIFZDUFUgY29udGV4dCkg b3ZlcnJpZGVzIGFsbCBlbHNlLg0KKyAgICAgKi8NCiAgICAgaWYgKCB0YXNrbGV0X3dvcmtfc2No ZWR1bGVkIHx8DQogICAgICAgICAgKGxpc3RfZW1wdHkocnVucSkgJiYgbGlzdF9lbXB0eSh3YWl0 cSkpIHx8DQogICAgICAgICAgdW5saWtlbHkoIWNwdW1hc2tfdGVzdF9jcHUoY3B1LCBTRURGX0NQ VU9OTElORShwZXJfY3B1KGNwdXBvb2wsIGNwdSkpKSkgKQ0KQEAgLTgzMyw5ICs3NzcsMTAgQEAg c3RhdGljIHN0cnVjdCB0YXNrX3NsaWNlIHNlZGZfZG9fc2NoZWR1bA0KICAgICAgICAgew0KICAg ICAgICAgICAgIHdhaXRpbmYgID0gbGlzdF9lbnRyeSh3YWl0cS0+bmV4dCwNCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHNlZGZfdmNwdV9pbmZvLGxpc3QpOw0KLSAg ICAgICAgICAgIC8qcmVydW4gc2NoZWR1bGVyLCB3aGVuIHNjaGVkdWxlZCBkb21haW4gcmVhY2hl cyBpdCdzDQotICAgICAgICAgICAgICBlbmQgb2Ygc2xpY2Ugb3IgdGhlIGZpcnN0IGRvbWFpbiBm cm9tIHRoZSB3YWl0cXVldWUNCi0gICAgICAgICAgICAgIGdldHMgcmVhZHkqLw0KKyAgICAgICAg ICAgIC8qIFJlcnVuIHNjaGVkdWxlciwgd2hlbiBzY2hlZHVsZWQgZG9tYWluIHJlYWNoZXMgaXQn cw0KKyAgICAgICAgICAgICAqIGVuZCBvZiBzbGljZSBvciB0aGUgZmlyc3QgZG9tYWluIGZyb20g dGhlIHdhaXRxdWV1ZQ0KKyAgICAgICAgICAgICAqIGdldHMgcmVhZHkuDQorICAgICAgICAgICAg ICovDQogICAgICAgICAgICAgcmV0LnRpbWUgPSBNSU4obm93ICsgcnVuaW5mLT5zbGljZSAtIHJ1 bmluZi0+Y3B1dGltZSwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBQRVJJT0RfQkVHSU4o d2FpdGluZikpIC0gbm93Ow0KICAgICAgICAgfQ0KQEAgLTg0NywxNCArNzkyLDE1IEBAIHN0YXRp YyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX3NjaGVkdWwNCiAgICAgZWxzZQ0KICAgICB7DQog ICAgICAgICB3YWl0aW5mICA9IGxpc3RfZW50cnkod2FpdHEtPm5leHQsc3RydWN0IHNlZGZfdmNw dV9pbmZvLCBsaXN0KTsNCi0gICAgICAgIC8qd2UgY291bGQgbm90IGZpbmQgYW55IHN1aXRhYmxl IGRvbWFpbiANCi0gICAgICAgICAgPT4gbG9vayBmb3IgZG9tYWlucyB0aGF0IGFyZSBhd2FyZSBv ZiBleHRyYXRpbWUqLw0KKyAgICAgICAgLyogV2UgY291bGQgbm90IGZpbmQgYW55IHN1aXRhYmxl IGRvbWFpbiANCisgICAgICAgICAqID0+IGxvb2sgZm9yIGRvbWFpbnMgdGhhdCBhcmUgYXdhcmUg b2YgZXh0cmF0aW1lKi8NCiAgICAgICAgIHJldCA9IHNlZGZfZG9fZXh0cmFfc2NoZWR1bGUobm93 LCBQRVJJT0RfQkVHSU4od2FpdGluZiksDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGV4dHJhcSwgY3B1KTsNCiAgICAgfQ0KIA0KLSAgICAvKlRPRE86IERvIHNvbWV0aGlu ZyBVU0VGVUwgd2hlbiB0aGlzIGhhcHBlbnMgYW5kIGZpbmQgb3V0LCB3aHkgaXQNCi0gICAgICBz dGlsbCBjYW4gaGFwcGVuISEhKi8NCisgICAgLyogVE9ETzogRG8gc29tZXRoaW5nIFVTRUZVTCB3 aGVuIHRoaXMgaGFwcGVucyBhbmQgZmluZCBvdXQsIHdoeSBpdA0KKyAgICAgKiBzdGlsbCBjYW4g aGFwcGVuISEhDQorICAgICAqLw0KICAgICBpZiAoIHJldC50aW1lIDwgMCkNCiAgICAgew0KICAg ICAgICAgcHJpbnRrKCJPdWNoISBXZSBhcmUgc2VyaW91c2x5IEJFSElORCBzY2hlZHVsZSEgJSJQ UklpNjQiXG4iLA0KQEAgLTg3NCw5ICs4MjAsNiBAQCBzdGF0aWMgc3RydWN0IHRhc2tfc2xpY2Ug c2VkZl9kb19zY2hlZHVsDQogDQogc3RhdGljIHZvaWQgc2VkZl9zbGVlcChjb25zdCBzdHJ1Y3Qg c2NoZWR1bGVyICpvcHMsIHN0cnVjdCB2Y3B1ICpkKQ0KIHsNCi0gICAgUFJJTlQoMiwic2VkZl9z bGVlcCB3YXMgY2FsbGVkLCBkb21haW4taWQgJWkuJWlcbiIsDQotICAgICAgICAgIGQtPmRvbWFp bi0+ZG9tYWluX2lkLCBkLT52Y3B1X2lkKTsNCi0gDQogICAgIGlmICggaXNfaWRsZV92Y3B1KGQp ICkNCiAgICAgICAgIHJldHVybjsNCiANCkBAIC05NzIsMjcgKzkxNSwyOSBAQCBzdGF0aWMgdm9p ZCBzZWRmX3NsZWVwKGNvbnN0IHN0cnVjdCBzY2hlDQogc3RhdGljIHZvaWQgdW5ibG9ja19zaG9y dF9leHRyYV9zdXBwb3J0KA0KICAgICBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8qIGluZiwgc190aW1l X3Qgbm93KQ0KIHsNCi0gICAgLyp0aGlzIHVuYmxvY2tpbmcgc2NoZW1lIHRyaWVzIHRvIHN1cHBv cnQgdGhlIGRvbWFpbiwgYnkgYXNzaWduaW5nIGl0DQotICAgIGEgcHJpb3JpdHkgaW4gZXh0cmF0 aW1lIGRpc3RyaWJ1dGlvbiBhY2NvcmRpbmcgdG8gdGhlIGxvc3Mgb2YgdGltZQ0KLSAgICBpbiB0 aGlzIHNsaWNlIGR1ZSB0byBibG9ja2luZyovDQorICAgIC8qIFRoaXMgdW5ibG9ja2luZyBzY2hl bWUgdHJpZXMgdG8gc3VwcG9ydCB0aGUgZG9tYWluLCBieSBhc3NpZ25pbmcgaXQNCisgICAgICog YSBwcmlvcml0eSBpbiBleHRyYXRpbWUgZGlzdHJpYnV0aW9uIGFjY29yZGluZyB0byB0aGUgbG9z cyBvZiB0aW1lDQorICAgICAqIGluIHRoaXMgc2xpY2UgZHVlIHRvIGJsb2NraW5nDQorICAgICAq Lw0KICAgICBzX3RpbWVfdCBwZW47DQogIA0KLSAgICAvKm5vIG1vcmUgcmVhbHRpbWUgZXhlY3V0 aW9uIGluIHRoaXMgcGVyaW9kISovDQorICAgIC8qIE5vIG1vcmUgcmVhbHRpbWUgZXhlY3V0aW9u IGluIHRoaXMgcGVyaW9kISAqLw0KICAgICBpbmYtPmRlYWRsX2FicyArPSBpbmYtPnBlcmlvZDsN CiAgICAgaWYgKCBsaWtlbHkoaW5mLT5ibG9ja19hYnMpICkNCiAgICAgew0KLSAgICAgICAgLy90 cmVhdCBibG9ja2VkIHRpbWUgYXMgY29uc3VtZWQgYnkgdGhlIGRvbWFpbiovDQorICAgICAgICAv KiBUcmVhdCBibG9ja2VkIHRpbWUgYXMgY29uc3VtZWQgYnkgdGhlIGRvbWFpbiAqLw0KICAgICAg ICAgLyppbmYtPmNwdXRpbWUgKz0gbm93IC0gaW5mLT5ibG9ja19hYnM7Ki8NCi0gICAgICAgIC8q cGVuYWx0eSBpcyB0aW1lIHRoZSBkb21haW4gd291bGQgaGF2ZQ0KLSAgICAgICAgICBoYWQgaWYg aXQgY29udGludWVkIHRvIHJ1biAqLw0KKyAgICAgICAgLyogUGVuYWx0eSBpcyB0aW1lIHRoZSBk b21haW4gd291bGQgaGF2ZQ0KKyAgICAgICAgICogaGFkIGlmIGl0IGNvbnRpbnVlZCB0byBydW4u DQorICAgICAgICAgKi8NCiAgICAgICAgIHBlbiA9IChpbmYtPnNsaWNlIC0gaW5mLT5jcHV0aW1l KTsNCiAgICAgICAgIGlmICggcGVuIDwgMCApDQogICAgICAgICAgICAgcGVuID0gMDsNCi0gICAg ICAgIC8qYWNjdW11bGF0ZSBhbGwgcGVuYWx0aWVzIG92ZXIgdGhlIHBlcmlvZHMqLw0KKyAgICAg ICAgLyogQWNjdW11bGF0ZSBhbGwgcGVuYWx0aWVzIG92ZXIgdGhlIHBlcmlvZHMgKi8NCiAgICAg ICAgIC8qaW5mLT5zaG9ydF9ibG9ja19sb3N0X3RvdCArPSBwZW47Ki8NCi0gICAgICAgIC8qc2V0 IHBlbmFsdHkgdG8gdGhlIGN1cnJlbnQgdmFsdWUqLw0KKyAgICAgICAgLyogU2V0IHBlbmFsdHkg dG8gdGhlIGN1cnJlbnQgdmFsdWUgKi8NCiAgICAgICAgIGluZi0+c2hvcnRfYmxvY2tfbG9zdF90 b3QgPSBwZW47DQotICAgICAgICAvKm5vdCBzdXJlIHdoaWNoIG9uZSBpcyBiZXR0ZXIuLiBidXQg c2VlbXMgdG8gd29yayB3ZWxsLi4uKi8NCisgICAgICAgIC8qIE5vdCBzdXJlIHdoaWNoIG9uZSBp cyBiZXR0ZXIuLiBidXQgc2VlbXMgdG8gd29yayB3ZWxsLi4uICovDQogICANCiAgICAgICAgIGlm ICggaW5mLT5zaG9ydF9ibG9ja19sb3N0X3RvdCApDQogICAgICAgICB7DQpAQCAtMTAwMiwyOCAr OTQ3LDMwIEBAIHN0YXRpYyB2b2lkIHVuYmxvY2tfc2hvcnRfZXh0cmFfc3VwcG9ydCgNCiAgICAg ICAgICAgICBpbmYtPnBlbl9leHRyYV9ibG9ja3MrKzsNCiAjZW5kaWYNCiAgICAgICAgICAgICBp ZiAoIGV4dHJhcV9vbihpbmYtPnZjcHUsIEVYVFJBX1BFTl9RKSApDQotICAgICAgICAgICAgICAg IC8qcmVtb3ZlIGRvbWFpbiBmb3IgcG9zc2libGUgcmVzb3J0aW5nISovDQorICAgICAgICAgICAg ICAgIC8qIFJlbW92ZSBkb21haW4gZm9yIHBvc3NpYmxlIHJlc29ydGluZyEgKi8NCiAgICAgICAg ICAgICAgICAgZXh0cmFxX2RlbChpbmYtPnZjcHUsIEVYVFJBX1BFTl9RKTsNCiAgICAgICAgICAg ICBlbHNlDQotICAgICAgICAgICAgICAgIC8qcmVtZW1iZXIgdGhhdCB3ZSB3YW50IHRvIGJlIG9u IHRoZSBwZW5hbHR5IHENCi0gICAgICAgICAgICAgICAgICBzbyB0aGF0IHdlIGNhbiBjb250aW51 ZSB3aGVuIHdlICh1bi0pYmxvY2sNCi0gICAgICAgICAgICAgICAgICBpbiBwZW5hbHR5LWV4dHJh dGltZSovDQorICAgICAgICAgICAgICAgIC8qIFJlbWVtYmVyIHRoYXQgd2Ugd2FudCB0byBiZSBv biB0aGUgcGVuYWx0eSBxDQorICAgICAgICAgICAgICAgICAqIHNvIHRoYXQgd2UgY2FuIGNvbnRp bnVlIHdoZW4gd2UgKHVuLSlibG9jaw0KKyAgICAgICAgICAgICAgICAgKiBpbiBwZW5hbHR5LWV4 dHJhdGltZQ0KKyAgICAgICAgICAgICAgICAgKi8NCiAgICAgICAgICAgICAgICAgaW5mLT5zdGF0 dXMgfD0gRVhUUkFfV0FOVF9QRU5fUTsNCiAgICANCi0gICAgICAgICAgICAvKihyZS0pYWRkIGRv bWFpbiB0byB0aGUgcGVuYWx0eSBleHRyYXEqLw0KKyAgICAgICAgICAgIC8qIChyZS0pYWRkIGRv bWFpbiB0byB0aGUgcGVuYWx0eSBleHRyYXEgKi8NCiAgICAgICAgICAgICBleHRyYXFfYWRkX3Nv cnRfdXBkYXRlKGluZi0+dmNwdSwgRVhUUkFfUEVOX1EsIDApOw0KICAgICAgICAgfQ0KICAgICB9 DQogDQotICAgIC8qZ2l2ZSBpdCBhIGZyZXNoIHNsaWNlIGluIHRoZSBuZXh0IHBlcmlvZCEqLw0K KyAgICAvKiBHaXZlIGl0IGEgZnJlc2ggc2xpY2UgaW4gdGhlIG5leHQgcGVyaW9kISAqLw0KICAg ICBpbmYtPmNwdXRpbWUgPSAwOw0KIH0NCiANCiANCiBzdGF0aWMgdm9pZCB1bmJsb2NrX2xvbmdf Y29uc19iKHN0cnVjdCBzZWRmX3ZjcHVfaW5mbyogaW5mLHNfdGltZV90IG5vdykNCiB7DQotICAg IC8qQ29uc2VydmF0aXZlIDJiKi8NCi0gICAgLypUcmVhdCB0aGUgdW5ibG9ja2luZyB0aW1lIGFz IGEgc3RhcnQgb2YgYSBuZXcgcGVyaW9kICovDQorICAgIC8qIENvbnNlcnZhdGl2ZSAyYiAqLw0K Kw0KKyAgICAvKiBUcmVhdCB0aGUgdW5ibG9ja2luZyB0aW1lIGFzIGEgc3RhcnQgb2YgYSBuZXcg cGVyaW9kICovDQogICAgIGluZi0+ZGVhZGxfYWJzID0gbm93ICsgaW5mLT5wZXJpb2Q7DQogICAg IGluZi0+Y3B1dGltZSA9IDA7DQogfQ0KQEAgLTEwNDYsMTUgKzk5MywxNiBAQCBzdGF0aWMgaW5s aW5lIGludCBnZXRfcnVuX3R5cGUoc3RydWN0IHZjDQogfQ0KIA0KIA0KLS8qQ29tcGFyZXMgdHdv IGRvbWFpbnMgaW4gdGhlIHJlbGF0aW9uIG9mIHdoZXRoZXIgdGhlIG9uZSBpcyBhbGxvd2VkIHRv DQotICBpbnRlcnJ1cHQgdGhlIG90aGVycyBleGVjdXRpb24uDQotICBJdCByZXR1cm5zIHRydWUg KCE9MCkgaWYgYSBzd2l0Y2ggdG8gdGhlIG90aGVyIGRvbWFpbiBpcyBnb29kLg0KLSAgQ3VycmVu dCBQcmlvcml0eSBzY2hlbWUgaXMgYXMgZm9sbG93czoNCi0gICBFREYgPiBMMCAocGVuYWx0eSBi YXNlZCkgZXh0cmEtdGltZSA+IA0KLSAgIEwxICh1dGlsaXphdGlvbikgZXh0cmEtdGltZSA+IGlk bGUtZG9tYWluDQotICBJbiB0aGUgc2FtZSBjbGFzcyBwcmlvcml0aWVzIGFyZSBhc3NpZ25lZCBh cyBmb2xsb3dpbmc6DQotICAgRURGOiBlYXJseSBkZWFkbGluZSA+IGxhdGUgZGVhZGxpbmUNCi0g ICBMMCBleHRyYS10aW1lOiBsb3dlciBzY29yZSA+IGhpZ2hlciBzY29yZSovDQorLyogQ29tcGFy ZXMgdHdvIGRvbWFpbnMgaW4gdGhlIHJlbGF0aW9uIG9mIHdoZXRoZXIgdGhlIG9uZSBpcyBhbGxv d2VkIHRvDQorICogaW50ZXJydXB0IHRoZSBvdGhlcnMgZXhlY3V0aW9uLg0KKyAqIEl0IHJldHVy bnMgdHJ1ZSAoIT0wKSBpZiBhIHN3aXRjaCB0byB0aGUgb3RoZXIgZG9tYWluIGlzIGdvb2QuDQor ICogQ3VycmVudCBQcmlvcml0eSBzY2hlbWUgaXMgYXMgZm9sbG93czoNCisgKiAgRURGID4gTDAg KHBlbmFsdHkgYmFzZWQpIGV4dHJhLXRpbWUgPiANCisgKiAgTDEgKHV0aWxpemF0aW9uKSBleHRy YS10aW1lID4gaWRsZS1kb21haW4NCisgKiBJbiB0aGUgc2FtZSBjbGFzcyBwcmlvcml0aWVzIGFy ZSBhc3NpZ25lZCBhcyBmb2xsb3dpbmc6DQorICogIEVERjogZWFybHkgZGVhZGxpbmUgPiBsYXRl IGRlYWRsaW5lDQorICogIEwwIGV4dHJhLXRpbWU6IGxvd2VyIHNjb3JlID4gaGlnaGVyIHNjb3Jl DQorICovDQogc3RhdGljIGlubGluZSBpbnQgc2hvdWxkX3N3aXRjaChzdHJ1Y3QgdmNwdSAqY3Vy LA0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHZjcHUgKm90aGVyLA0K ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc190aW1lX3Qgbm93KQ0KQEAgLTEwNjMs MTkgKzEwMTEsMTkgQEAgc3RhdGljIGlubGluZSBpbnQgc2hvdWxkX3N3aXRjaChzdHJ1Y3Qgdg0K ICAgICBjdXJfaW5mICAgPSBFRE9NX0lORk8oY3VyKTsNCiAgICAgb3RoZXJfaW5mID0gRURPTV9J TkZPKG90aGVyKTsNCiAgDQotICAgIC8qIENoZWNrIHdoZXRoZXIgd2UgbmVlZCB0byBtYWtlIGFu IGVhcmxpZXIgc2NoZWR1bGluZyBkZWNpc2lvbi4gKi8NCisgICAgLyogQ2hlY2sgd2hldGhlciB3 ZSBuZWVkIHRvIG1ha2UgYW4gZWFybGllciBzY2hlZHVsaW5nIGRlY2lzaW9uICovDQogICAgIGlm ICggUEVSSU9EX0JFR0lOKG90aGVyX2luZikgPCANCiAgICAgICAgICBDUFVfSU5GTyhvdGhlci0+ cHJvY2Vzc29yKS0+Y3VycmVudF9zbGljZV9leHBpcmVzICkNCiAgICAgICAgIHJldHVybiAxOw0K IA0KLSAgICAvKiBObyB0aW1pbmctYmFzZWQgc3dpdGNoZXMgbmVlZCB0byBiZSB0YWtlbiBpbnRv IGFjY291bnQgaGVyZS4gKi8NCisgICAgLyogTm8gdGltaW5nLWJhc2VkIHN3aXRjaGVzIG5lZWQg dG8gYmUgdGFrZW4gaW50byBhY2NvdW50IGhlcmUgKi8NCiAgICAgc3dpdGNoICggZ2V0X3J1bl90 eXBlKGN1cikgKQ0KICAgICB7DQogICAgIGNhc2UgRE9NQUlOX0VERjoNCi0gICAgICAgIC8qIERv IG5vdCBpbnRlcnJ1cHQgYSBydW5uaW5nIEVERiBkb21haW4uICovDQorICAgICAgICAvKiBEbyBu b3QgaW50ZXJydXB0IGEgcnVubmluZyBFREYgZG9tYWluICovDQogICAgICAgICByZXR1cm4gMDsN CiAgICAgY2FzZSBET01BSU5fRVhUUkFfUEVOOg0KLSAgICAgICAgLyogQ2hlY2sgd2hldGhlciB3 ZSBhbHNvIHdhbnQgdGhlIEwwIGV4LXEgd2l0aCBsb3dlciBzY29yZS4gKi8NCisgICAgICAgIC8q IENoZWNrIHdoZXRoZXIgd2UgYWxzbyB3YW50IHRoZSBMMCBleC1xIHdpdGggbG93ZXIgc2NvcmUg Ki8NCiAgICAgICAgIHJldHVybiAoKG90aGVyX2luZi0+c3RhdHVzICYgRVhUUkFfV0FOVF9QRU5f USkgJiYNCiAgICAgICAgICAgICAgICAgKG90aGVyX2luZi0+c2NvcmVbRVhUUkFfUEVOX1FdIDwg DQogICAgICAgICAgICAgICAgICBjdXJfaW5mLT5zY29yZVtFWFRSQV9QRU5fUV0pKTsNCkBAIC0x MDk2LDE4ICsxMDQ0LDExIEBAIHN0YXRpYyB2b2lkIHNlZGZfd2FrZShjb25zdCBzdHJ1Y3Qgc2No ZWQNCiAgICAgc190aW1lX3QgICAgICAgICAgICAgIG5vdyA9IE5PVygpOw0KICAgICBzdHJ1Y3Qg c2VkZl92Y3B1X2luZm8qIGluZiA9IEVET01fSU5GTyhkKTsNCiANCi0gICAgUFJJTlQoMywgInNl ZGZfd2FrZSB3YXMgY2FsbGVkLCBkb21haW4taWQgJWkuJWlcbiIsZC0+ZG9tYWluLT5kb21haW5f aWQsDQotICAgICAgICAgIGQtPnZjcHVfaWQpOw0KLQ0KICAgICBpZiAoIHVubGlrZWx5KGlzX2lk bGVfdmNwdShkKSkgKQ0KICAgICAgICAgcmV0dXJuOw0KICAgIA0KICAgICBpZiAoIHVubGlrZWx5 KF9fdGFza19vbl9xdWV1ZShkKSkgKQ0KLSAgICB7DQotICAgICAgICBQUklOVCgzLCJcdGRvbWFp biAlaS4laSBpcyBhbHJlYWR5IGluIHNvbWUgcXVldWVcbiIsDQotICAgICAgICAgICAgICBkLT5k b21haW4tPmRvbWFpbl9pZCwgZC0+dmNwdV9pZCk7DQogICAgICAgICByZXR1cm47DQotICAgIH0N CiANCiAgICAgQVNTRVJUKCFzZWRmX3J1bm5hYmxlKGQpKTsNCiAgICAgaW5mLT5zdGF0dXMgJj0g flNFREZfQVNMRUVQOw0KQEAgLTExMTYsMjggKzEwNTcsMjQgQEAgc3RhdGljIHZvaWQgc2VkZl93 YWtlKGNvbnN0IHN0cnVjdCBzY2hlZA0KICANCiAgICAgaWYgKCB1bmxpa2VseShpbmYtPmRlYWRs X2FicyA9PSAwKSApDQogICAgIHsNCi0gICAgICAgIC8qaW5pdGlhbCBzZXR1cCBvZiB0aGUgZGVh ZGxpbmUqLw0KKyAgICAgICAgLyogSW5pdGlhbCBzZXR1cCBvZiB0aGUgZGVhZGxpbmUgKi8NCiAg ICAgICAgIGluZi0+ZGVhZGxfYWJzID0gbm93ICsgaW5mLT5zbGljZTsNCiAgICAgfQ0KICAgDQot ICAgIFBSSU5UKDMsICJ3YWtpbmcgdXAgZG9tYWluICVpLiVpIChkZWFkbD0gJSJQUkl1NjQiIHBl cmlvZD0gJSJQUkl1NjQNCi0gICAgICAgICAgIm5vdz0gJSJQUkl1NjQiKVxuIiwNCi0gICAgICAg ICAgZC0+ZG9tYWluLT5kb21haW5faWQsIGQtPnZjcHVfaWQsIGluZi0+ZGVhZGxfYWJzLCBpbmYt PnBlcmlvZCwgbm93KTsNCi0NCiAjaWZkZWYgU0VERl9TVEFUUyANCiAgICAgaW5mLT5ibG9ja190 b3QrKzsNCiAjZW5kaWYNCiANCiAgICAgaWYgKCB1bmxpa2VseShub3cgPCBQRVJJT0RfQkVHSU4o aW5mKSkgKQ0KICAgICB7DQotICAgICAgICBQUklOVCg0LCJleHRyYXRpbWUgdW5ibG9ja1xuIik7 DQotICAgICAgICAvKiB1bmJsb2NraW5nIGluIGV4dHJhLXRpbWUhICovDQorICAgICAgICAvKiBV bmJsb2NraW5nIGluIGV4dHJhLXRpbWUhICovDQogICAgICAgICBpZiAoIGluZi0+c3RhdHVzICYg RVhUUkFfV0FOVF9QRU5fUSApDQogICAgICAgICB7DQotICAgICAgICAgICAgLyp3ZSBoYXZlIGEg ZG9tYWluIHRoYXQgd2FudHMgY29tcGVuc2F0aW9uDQotICAgICAgICAgICAgICBmb3IgYmxvY2sg cGVuYWx0eSBhbmQgZGlkIGp1c3QgYmxvY2sgaW4NCi0gICAgICAgICAgICAgIGl0cyBjb21wZW5z YXRpb24gdGltZS4gR2l2ZSBpdCBhbm90aGVyDQotICAgICAgICAgICAgICBjaGFuY2UhKi8NCisg ICAgICAgICAgICAvKiBXZSBoYXZlIGEgZG9tYWluIHRoYXQgd2FudHMgY29tcGVuc2F0aW9uDQor ICAgICAgICAgICAgICogZm9yIGJsb2NrIHBlbmFsdHkgYW5kIGRpZCBqdXN0IGJsb2NrIGluDQor ICAgICAgICAgICAgICogaXRzIGNvbXBlbnNhdGlvbiB0aW1lLiBHaXZlIGl0IGFub3RoZXINCisg ICAgICAgICAgICAgKiBjaGFuY2UhDQorICAgICAgICAgICAgICovDQogICAgICAgICAgICAgZXh0 cmFxX2FkZF9zb3J0X3VwZGF0ZShkLCBFWFRSQV9QRU5fUSwgMCk7DQogICAgICAgICB9DQogICAg ICAgICBleHRyYXFfY2hlY2tfYWRkX3VuYmxvY2tlZChkLCAwKTsNCkBAIC0xMTQ2LDggKzEwODMs NyBAQCBzdGF0aWMgdm9pZCBzZWRmX3dha2UoY29uc3Qgc3RydWN0IHNjaGVkDQogICAgIHsgIA0K ICAgICAgICAgaWYgKCBub3cgPCBpbmYtPmRlYWRsX2FicyApDQogICAgICAgICB7DQotICAgICAg ICAgICAgUFJJTlQoNCwic2hvcnQgdW5ibG9ja2luZ1xuIik7DQotICAgICAgICAgICAgLypzaG9y dCBibG9ja2luZyovDQorICAgICAgICAgICAgLyogU2hvcnQgYmxvY2tpbmcgKi8NCiAjaWZkZWYg U0VERl9TVEFUUw0KICAgICAgICAgICAgIGluZi0+c2hvcnRfYmxvY2tfdG90Kys7DQogI2VuZGlm DQpAQCAtMTE1Nyw4ICsxMDkzLDcgQEAgc3RhdGljIHZvaWQgc2VkZl93YWtlKGNvbnN0IHN0cnVj dCBzY2hlZA0KICAgICAgICAgfQ0KICAgICAgICAgZWxzZQ0KICAgICAgICAgew0KLSAgICAgICAg ICAgIFBSSU5UKDQsImxvbmcgdW5ibG9ja2luZ1xuIik7DQotICAgICAgICAgICAgLypsb25nIHVu YmxvY2tpbmcqLw0KKyAgICAgICAgICAgIC8qIExvbmcgdW5ibG9ja2luZyAqLw0KICNpZmRlZiBT RURGX1NUQVRTDQogICAgICAgICAgICAgaW5mLT5sb25nX2Jsb2NrX3RvdCsrOw0KICNlbmRpZg0K QEAgLTExNjgsMjQgKzExMDMsMTMgQEAgc3RhdGljIHZvaWQgc2VkZl93YWtlKGNvbnN0IHN0cnVj dCBzY2hlZA0KICAgICAgICAgfQ0KICAgICB9DQogDQotICAgIFBSSU5UKDMsICJ3b2tlIHVwIGRv bWFpbiAlaS4laSAoZGVhZGw9ICUiUFJJdTY0IiBwZXJpb2Q9ICUiUFJJdTY0DQotICAgICAgICAg ICJub3c9ICUiUFJJdTY0IilcbiIsDQotICAgICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBk LT52Y3B1X2lkLCBpbmYtPmRlYWRsX2FicywNCi0gICAgICAgICAgaW5mLT5wZXJpb2QsIG5vdyk7 DQotDQogICAgIGlmICggUEVSSU9EX0JFR0lOKGluZikgPiBub3cgKQ0KLSAgICB7DQogICAgICAg ICBfX2FkZF90b193YWl0cXVldWVfc29ydChkKTsNCi0gICAgICAgIFBSSU5UKDMsImFkZGVkIHRv IHdhaXRxXG4iKTsNCi0gICAgfQ0KICAgICBlbHNlDQotICAgIHsNCiAgICAgICAgIF9fYWRkX3Rv X3J1bnF1ZXVlX3NvcnQoZCk7DQotICAgICAgICBQUklOVCgzLCJhZGRlZCB0byBydW5xXG4iKTsN Ci0gICAgfQ0KICANCiAjaWZkZWYgU0VERl9TVEFUUw0KLSAgICAvKmRvIHNvbWUgc3RhdGlzdGlj cyBoZXJlLi4uKi8NCisgICAgLyogRG8gc29tZSBzdGF0aXN0aWNzIGhlcmUuLi4gKi8NCiAgICAg aWYgKCBpbmYtPmJsb2NrX2FicyAhPSAwICkNCiAgICAgew0KICAgICAgICAgaW5mLT5ibG9ja190 aW1lX3RvdCArPSBub3cgLSBpbmYtPmJsb2NrX2FiczsNCkBAIC0xMTk0LDEyICsxMTE4LDEzIEBA IHN0YXRpYyB2b2lkIHNlZGZfd2FrZShjb25zdCBzdHJ1Y3Qgc2NoZWQNCiAgICAgfQ0KICNlbmRp Zg0KIA0KLSAgICAvKnNhbml0eSBjaGVjazogbWFrZSBzdXJlIGVhY2ggZXh0cmEtYXdhcmUgZG9t YWluIElTIG9uIHRoZSB1dGlsLXEhKi8NCisgICAgLyogU2FuaXR5IGNoZWNrOiBtYWtlIHN1cmUg ZWFjaCBleHRyYS1hd2FyZSBkb21haW4gSVMgb24gdGhlIHV0aWwtcSEgKi8NCiAgICAgQVNTRVJU KElNUExZKGluZi0+c3RhdHVzICYgRVhUUkFfQVdBUkUsIGV4dHJhcV9vbihkLCBFWFRSQV9VVElM X1EpKSk7DQogICAgIEFTU0VSVChfX3Rhc2tfb25fcXVldWUoZCkpOw0KLSAgICAvKmNoZWNrIHdo ZXRoZXIgdGhlIGF3YWtlbmVkIHRhc2sgbmVlZHMgdG8gaW52b2tlIHRoZSBkb19zY2hlZHVsZQ0K LSAgICAgIHJvdXRpbmUuIFRyeSB0byBhdm9pZCB1bm5lY2Vzc2FyeSBydW5zIGJ1dDoNCi0gICAg ICBTYXZlIGFwcHJveGltYXRpb246IEFsd2F5cyBzd2l0Y2ggdG8gc2NoZWR1bGVyISovDQorICAg IC8qIENoZWNrIHdoZXRoZXIgdGhlIGF3YWtlbmVkIHRhc2sgbmVlZHMgdG8gaW52b2tlIHRoZSBk b19zY2hlZHVsZQ0KKyAgICAgKiByb3V0aW5lLiBUcnkgdG8gYXZvaWQgdW5uZWNlc3NhcnkgcnVu cyBidXQ6DQorICAgICAqIFNhdmUgYXBwcm94aW1hdGlvbjogQWx3YXlzIHN3aXRjaCB0byBzY2hl ZHVsZXIhDQorICAgICAqLw0KICAgICBBU1NFUlQoZC0+cHJvY2Vzc29yID49IDApOw0KICAgICBB U1NFUlQoZC0+cHJvY2Vzc29yIDwgbnJfY3B1X2lkcyk7DQogICAgIEFTU0VSVChwZXJfY3B1KHNj aGVkdWxlX2RhdGEsIGQtPnByb2Nlc3NvcikuY3Vycik7DQpAQCAtMTI0NCw3ICsxMTY5LDcgQEAg c3RhdGljIHZvaWQgc2VkZl9kdW1wX2RvbWFpbihzdHJ1Y3QgdmNwdQ0KIH0NCiANCiANCi0vKiBk dW1wcyBhbGwgZG9tYWlucyBvbiB0aGUgc3BlY2lmaWVkIGNwdSAqLw0KKy8qIER1bXBzIGFsbCBk b21haW5zIG9uIHRoZSBzcGVjaWZpZWQgY3B1ICovDQogc3RhdGljIHZvaWQgc2VkZl9kdW1wX2Nw dV9zdGF0ZShjb25zdCBzdHJ1Y3Qgc2NoZWR1bGVyICpvcHMsIGludCBpKQ0KIHsNCiAgICAgc3Ry dWN0IGxpc3RfaGVhZCAgICAgICpsaXN0LCAqcXVldWUsICp0bXA7DQpAQCAtMTMxOSw3ICsxMjQ0 LDcgQEAgc3RhdGljIHZvaWQgc2VkZl9kdW1wX2NwdV9zdGF0ZShjb25zdCBzdA0KIH0NCiANCiAN Ci0vKiBBZGp1c3RzIHBlcmlvZHMgYW5kIHNsaWNlcyBvZiB0aGUgZG9tYWlucyBhY2NvcmRpbmds eSB0byB0aGVpciB3ZWlnaHRzLiAqLw0KKy8qIEFkanVzdHMgcGVyaW9kcyBhbmQgc2xpY2VzIG9m IHRoZSBkb21haW5zIGFjY29yZGluZ2x5IHRvIHRoZWlyIHdlaWdodHMgKi8NCiBzdGF0aWMgaW50 IHNlZGZfYWRqdXN0X3dlaWdodHMoc3RydWN0IGNwdXBvb2wgKmMsIHN0cnVjdCB4ZW5fZG9tY3Rs X3NjaGVkdWxlcl9vcCAqY21kKQ0KIHsNCiAgICAgc3RydWN0IHZjcHUgKnA7DQpAQCAtMTMzNSw3 ICsxMjYwLDcgQEAgc3RhdGljIGludCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBjcA0KICAg ICAgICAgcmV0dXJuIC1FTk9NRU07DQogICAgIH0NCiANCi0gICAgLyogU3VtIGFjcm9zcyBhbGwg d2VpZ2h0cy4gKi8NCisgICAgLyogU3VtIGFjcm9zcyBhbGwgd2VpZ2h0cyAqLw0KICAgICByY3Vf cmVhZF9sb2NrKCZkb21saXN0X3JlYWRfbG9jayk7DQogICAgIGZvcl9lYWNoX2RvbWFpbl9pbl9j cHVwb29sKCBkLCBjICkNCiAgICAgew0KQEAgLTEzNTAsMTEgKzEyNzUsMTMgQEAgc3RhdGljIGlu dCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBjcA0KICAgICAgICAgICAgIH0NCiAgICAgICAg ICAgICBlbHNlDQogICAgICAgICAgICAgew0KLSAgICAgICAgICAgICAgICAvKmRvbid0IG1vZGlm eSBkb21haW5zIHdobyBkb24ndCBoYXZlIGEgd2VpZ2h0LCBidXQgc3VtDQotICAgICAgICAgICAg ICAgICAgdXAgdGhlIHRpbWUgdGhleSBuZWVkLCBwcm9qZWN0ZWQgdG8gYSBXRUlHSFRfUEVSSU9E LA0KLSAgICAgICAgICAgICAgICAgIHNvIHRoYXQgdGhpcyB0aW1lIGlzIG5vdCBnaXZlbiB0byB0 aGUgd2VpZ2h0LWRyaXZlbg0KLSAgICAgICAgICAgICAgICAgIGRvbWFpbnMqLw0KLSAgICAgICAg ICAgICAgICAvKmNoZWNrIGZvciBvdmVyZmxvd3MqLw0KKyAgICAgICAgICAgICAgICAvKiBEb24n dCBtb2RpZnkgZG9tYWlucyB3aG8gZG9uJ3QgaGF2ZSBhIHdlaWdodCwgYnV0IHN1bQ0KKyAgICAg ICAgICAgICAgICAgKiB1cCB0aGUgdGltZSB0aGV5IG5lZWQsIHByb2plY3RlZCB0byBhIFdFSUdI VF9QRVJJT0QsDQorICAgICAgICAgICAgICAgICAqIHNvIHRoYXQgdGhpcyB0aW1lIGlzIG5vdCBn aXZlbiB0byB0aGUgd2VpZ2h0LWRyaXZlbg0KKyAgICAgICAgICAgICAgICAgKiAgZG9tYWlucw0K KyAgICAgICAgICAgICAgICAgKi8NCisNCisgICAgICAgICAgICAgICAgLyogQ2hlY2sgZm9yIG92 ZXJmbG93cyAqLw0KICAgICAgICAgICAgICAgICBBU1NFUlQoKFdFSUdIVF9QRVJJT0QgPCBVTE9O R19NQVgpIA0KICAgICAgICAgICAgICAgICAgICAgICAgJiYgKEVET01fSU5GTyhwKS0+c2xpY2Vf b3JpZyA8IFVMT05HX01BWCkpOw0KICAgICAgICAgICAgICAgICBzdW10W2NwdV0gKz0gDQpAQCAt MTM2NSw3ICsxMjkyLDcgQEAgc3RhdGljIGludCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBj cA0KICAgICB9DQogICAgIHJjdV9yZWFkX3VubG9jaygmZG9tbGlzdF9yZWFkX2xvY2spOw0KIA0K LSAgICAvKiBBZGp1c3QgYWxsIHNsaWNlcyAoYW5kIHBlcmlvZHMpIHRvIHRoZSBuZXcgd2VpZ2h0 LiAqLw0KKyAgICAvKiBBZGp1c3QgYWxsIHNsaWNlcyAoYW5kIHBlcmlvZHMpIHRvIHRoZSBuZXcg d2VpZ2h0ICovDQogICAgIHJjdV9yZWFkX2xvY2soJmRvbWxpc3RfcmVhZF9sb2NrKTsNCiAgICAg Zm9yX2VhY2hfZG9tYWluX2luX2NwdXBvb2woIGQsIGMgKQ0KICAgICB7DQpAQCAtMTM5MywyMCAr MTMyMCwxNSBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0X3dlaWdodHMoc3RydWN0IGNwDQogfQ0K IA0KIA0KLS8qIHNldCBvciBmZXRjaCBkb21haW4gc2NoZWR1bGluZyBwYXJhbWV0ZXJzICovDQor LyogU2V0IG9yIGZldGNoIGRvbWFpbiBzY2hlZHVsaW5nIHBhcmFtZXRlcnMgKi8NCiBzdGF0aWMg aW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlZHVsZXIgKm9wcywgc3RydWN0IGRvbWFp biAqcCwgc3RydWN0IHhlbl9kb21jdGxfc2NoZWR1bGVyX29wICpvcCkNCiB7DQogICAgIHN0cnVj dCB2Y3B1ICp2Ow0KICAgICBpbnQgcmM7DQogDQotICAgIFBSSU5UKDIsInNlZGZfYWRqdXN0IHdh cyBjYWxsZWQsIGRvbWFpbi1pZCAlaSBuZXcgcGVyaW9kICUiUFJJdTY0IiAiDQotICAgICAgICAg ICJuZXcgc2xpY2UgJSJQUkl1NjQiXG5sYXRlbmN5ICUiUFJJdTY0IiBleHRyYTolc1xuIiwNCi0g ICAgICAgICAgcC0+ZG9tYWluX2lkLCBvcC0+dS5zZWRmLnBlcmlvZCwgb3AtPnUuc2VkZi5zbGlj ZSwNCi0gICAgICAgICAgb3AtPnUuc2VkZi5sYXRlbmN5LCAob3AtPnUuc2VkZi5leHRyYXRpbWUp PyJ5ZXMiOiJubyIpOw0KLQ0KICAgICBpZiAoIG9wLT5jbWQgPT0gWEVOX0RPTUNUTF9TQ0hFRE9Q X3B1dGluZm8gKQ0KICAgICB7DQotICAgICAgICAvKiBDaGVjayBmb3Igc2FuZSBwYXJhbWV0ZXJz LiAqLw0KKyAgICAgICAgLyogQ2hlY2sgZm9yIHNhbmUgcGFyYW1ldGVycyAqLw0KICAgICAgICAg aWYgKCAhb3AtPnUuc2VkZi5wZXJpb2QgJiYgIW9wLT51LnNlZGYud2VpZ2h0ICkNCiAgICAgICAg ICAgICByZXR1cm4gLUVJTlZBTDsNCiAgICAgICAgIGlmICggb3AtPnUuc2VkZi53ZWlnaHQgKQ0K QEAgLTE0MTQsNyArMTMzNiw3IEBAIHN0YXRpYyBpbnQgc2VkZl9hZGp1c3QoY29uc3Qgc3RydWN0 IHNjaGUNCiAgICAgICAgICAgICBpZiAoIChvcC0+dS5zZWRmLmV4dHJhdGltZSAmIEVYVFJBX0FX QVJFKSAmJg0KICAgICAgICAgICAgICAgICAgKCFvcC0+dS5zZWRmLnBlcmlvZCkgKQ0KICAgICAg ICAgICAgIHsNCi0gICAgICAgICAgICAgICAgLyogV2VpZ2h0LWRyaXZlbiBkb21haW5zIHdpdGgg ZXh0cmF0aW1lIG9ubHkuICovDQorICAgICAgICAgICAgICAgIC8qIFdlaWdodC1kcml2ZW4gZG9t YWlucyB3aXRoIGV4dHJhdGltZSBvbmx5ICovDQogICAgICAgICAgICAgICAgIGZvcl9lYWNoX3Zj cHUgKCBwLCB2ICkNCiAgICAgICAgICAgICAgICAgew0KICAgICAgICAgICAgICAgICAgICAgRURP TV9JTkZPKHYpLT5leHRyYXdlaWdodCA9IG9wLT51LnNlZGYud2VpZ2h0Ow0KQEAgLTE0MjUsNyAr MTM0Nyw3IEBAIHN0YXRpYyBpbnQgc2VkZl9hZGp1c3QoY29uc3Qgc3RydWN0IHNjaGUNCiAgICAg ICAgICAgICB9DQogICAgICAgICAgICAgZWxzZQ0KICAgICAgICAgICAgIHsNCi0gICAgICAgICAg ICAgICAgLyogV2VpZ2h0LWRyaXZlbiBkb21haW5zIHdpdGggcmVhbC10aW1lIGV4ZWN1dGlvbi4g Ki8NCisgICAgICAgICAgICAgICAgLyogV2VpZ2h0LWRyaXZlbiBkb21haW5zIHdpdGggcmVhbC10 aW1lIGV4ZWN1dGlvbiAqLw0KICAgICAgICAgICAgICAgICBmb3JfZWFjaF92Y3B1ICggcCwgdiAp DQogICAgICAgICAgICAgICAgICAgICBFRE9NX0lORk8odiktPndlaWdodCA9IG9wLT51LnNlZGYu d2VpZ2h0Ow0KICAgICAgICAgICAgIH0NCkBAIC0xNDM1LDggKzEzNTcsNyBAQCBzdGF0aWMgaW50 IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlDQogICAgICAgICAgICAgLyogVGltZS1kcml2 ZW4gZG9tYWlucy4gKi8NCiAgICAgICAgICAgICBmb3JfZWFjaF92Y3B1ICggcCwgdiApDQogICAg ICAgICAgICAgew0KLSAgICAgICAgICAgICAgICAvKg0KLSAgICAgICAgICAgICAgICAgKiBTYW5p dHkgY2hlY2tpbmc6IG5vdGUgdGhhdCBkaXNhYmxpbmcgZXh0cmEgd2VpZ2h0IHJlcXVpcmVzDQor ICAgICAgICAgICAgICAgIC8qIFNhbml0eSBjaGVja2luZzogbm90ZSB0aGF0IGRpc2FibGluZyBl eHRyYSB3ZWlnaHQgcmVxdWlyZXMNCiAgICAgICAgICAgICAgICAgICogdGhhdCB3ZSBzZXQgYSBu b24temVybyBzbGljZS4NCiAgICAgICAgICAgICAgICAgICovDQogICAgICAgICAgICAgICAgIGlm ICggKG9wLT51LnNlZGYucGVyaW9kID4gUEVSSU9EX01BWCkgfHwNCkBAIC0xNDc3LDcgKzEzOTgs NiBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlDQogICAgICAgICBv cC0+dS5zZWRmLndlaWdodCAgICA9IEVET01fSU5GTyhwLT52Y3B1WzBdKS0+d2VpZ2h0Ow0KICAg ICB9DQogDQotICAgIFBSSU5UKDIsInNlZGZfYWRqdXN0X2ZpbmlzaGVkXG4iKTsNCiAgICAgcmV0 dXJuIDA7DQogfQ0KIA0K --=-3p5/0djGq6n5G1gGRftX-- --=-4GhoPkvT2knwTpwLdibp 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) iEYEABECAAYFAk7wyjgACgkQk4XaBE3IOsR/vACgqGtZKPaaw+mk+E5KLy5ydkVO 0dgAn2xbXZ2l2w6UXsUeFgUEefZ0Zm8r =lJaO -----END PGP SIGNATURE----- --=-4GhoPkvT2knwTpwLdibp-- --===============4953755209351780878== 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 --===============4953755209351780878==--