From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dario Faggioli Subject: [PATCHv3] sedf: remove useless tracing printk and harmonize comments style. Date: Thu, 05 Jan 2012 16:17:01 +0100 Message-ID: <1325776621.2728.7.camel@Solace> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="===============0162675564886136273==" 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 --===============0162675564886136273== Content-Type: multipart/signed; micalg="pgp-sha1"; protocol="application/pgp-signature"; boundary="=-BVBDbEUzgZPrsy4cOGLY" --=-BVBDbEUzgZPrsy4cOGLY Content-Type: multipart/mixed; boundary="=-Q+nO0nZUPH9ih0IDSLo0" --=-Q+nO0nZUPH9ih0IDSLo0 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 efaa28639a71 xen/common/sched_sedf.c --- a/xen/common/sched_sedf.c Wed Jan 04 16:12:44 2012 +0000 +++ b/xen/common/sched_sedf.c Thu Jan 05 15:02:30 2012 +0100 @@ -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 @@ -71,34 +63,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; /* =3D worst 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 @@ -165,18 +158,17 @@ static inline void extraq_del(struct vcp { struct list_head *list =3D EXTRALIST(d,i); ASSERT(extraq_on(d,i)); - PRINT(3, "Removing domain %i.%i from L%i extraq\n", - d->domain->domain_id, d->vcpu_id, i); list_del(list); list->next =3D NULL; ASSERT(!extraq_on(d, i)); } =20 -/* adds a domain to the queue of processes which are aware of extra time. = List - is sorted by score, where a lower score means higher priority for an ex= tra - slice. It also updates the score, by simply subtracting a fixed value f= rom - each entry, in order to avoid overflow. The algorithm works by simply - charging each domain that recieved extratime with an inverse of its wei= ght. +/* + * Adds a domain to the queue of processes which are aware of extra time. = List + * is sorted by score, where a lower score means higher priority for an ex= tra + * slice. It also updates the score, by simply subtracting a fixed value f= rom + * each entry, in order to avoid overflow. The algorithm works by simply + * charging each domain that recieved extratime with an inverse of its wei= ght. */=20 static inline void extraq_add_sort_update(struct vcpu *d, int i, int sub) { @@ -185,11 +177,6 @@ static inline void extraq_add_sort_updat =20 ASSERT(!extraq_on(d,i)); =20 - PRINT(3, "Adding domain %i.%i (score=3D %i, short_pen=3D %"PRIi64")" - " to L%i extraq\n", - d->domain->domain_id, d->vcpu_id, EDOM_INFO(d)->score[i], - EDOM_INFO(d)->short_block_lost_tot, i); - /* * Iterate through all elements to find our "hole" and on our way * update all the other scores. @@ -200,25 +187,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 @@ -228,29 +208,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 @@ -259,7 +224,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 @@ -272,8 +237,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)); @@ -286,13 +249,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 @@ -310,30 +272,28 @@ static int name##_comp(struct list_head* return 1; \ } =20 -/* adds a domain to the queue of processes which wait for the beginning of= the - next period; this list is therefore sortet by this time, which is simpl= y - absol. deadline - period +/* + * Adds a domain to the queue of processes which wait for the beginning of= the + * next period; this list is therefore sortet by this time, which is simpl= y + * absol. deadline - period. */=20 DOMAIN_COMPARER(waitq, list, PERIOD_BEGIN(d1), PERIOD_BEGIN(d2)); static inline void __add_to_waitqueue_sort(struct vcpu *v) { ASSERT(!__task_on_queue(v)); - PRINT(3,"Adding domain %i.%i (bop=3D %"PRIu64") to waitq\n", - v->domain->domain_id, v->vcpu_id, PERIOD_BEGIN(EDOM_INFO(v))); list_insert_sort(WAITQ(v->processor), LIST(v), waitq_comp); ASSERT(__task_on_queue(v)); } =20 -/* adds a domain to the queue of processes which have started their curren= t - period and are runnable (i.e. not blocked, dieing,...). The first eleme= nt - on this list is running on the processor, if the list is empty the idle - task will run. As we are implementing EDF, this list is sorted by deadl= ines. +/* + * Adds a domain to the queue of processes which have started their curren= t + * period and are runnable (i.e. not blocked, dieing,...). The first eleme= nt + * on this list is running on the processor, if the list is empty the idle + * task will run. As we are implementing EDF, this list is sorted by deadl= ines. */=20 DOMAIN_COMPARER(runq, list, d1->deadl_abs, d2->deadl_abs); static inline void __add_to_runqueue_sort(struct vcpu *v) { - PRINT(3,"Adding domain %i.%i (deadl=3D %"PRIu64") to runq\n", - v->domain->domain_id, v->vcpu_id, EDOM_INFO(v)->deadl_abs); list_insert_sort(RUNQ(v->processor), LIST(v), runq_comp); } =20 @@ -361,12 +321,12 @@ static void *sedf_alloc_vdata(const stru =20 inf->vcpu =3D v; =20 - /* Every VCPU gets an equal share of extratime by default. */ + /* Every VCPU gets an equal share of extratime by default */ inf->deadl_abs =3D 0; inf->latency =3D 0; inf->status =3D EXTRA_AWARE | SEDF_ASLEEP; inf->extraweight =3D 1; - /* Upon creation all domain are best-effort. */ + /* Upon creation all domain are best-effort */ inf->period =3D WEIGHT_PERIOD; inf->slice =3D 0; =20 @@ -450,21 +410,19 @@ static void desched_edf_dom(s_time_t now { struct sedf_vcpu_info* inf =3D EDOM_INFO(d); =20 - /* Current domain is running in real time mode. */ + /* Current domain is running in real time mode */ ASSERT(__task_on_queue(d)); =20 - /* Update the domain's cputime. */ + /* Update the domain's cputime */ inf->cputime +=3D now - inf->sched_start_abs; =20 - /* - * Scheduling decisions which don't remove the running domain from the - * runq.=20 - */ + /* Scheduling decisions which don't remove the running domain from + * the runq */ if ( (inf->cputime < inf->slice) && sedf_runnable(d) ) return; =20 __del_from_queue(d); - =20 + /* * Manage bookkeeping (i.e. calculate next deadline, memorise * overrun-time of slice) of finished domains. @@ -475,30 +433,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) ) @@ -518,8 +476,6 @@ static void update_queues( struct list_head *cur, *tmp; struct sedf_vcpu_info *curinf; =20 - PRINT(3,"Updating waitq..\n"); - /* * Check for the first elements of the waitqueue, whether their * next period has already started. @@ -527,41 +483,32 @@ static void update_queues( list_for_each_safe ( cur, tmp, waitq ) { curinf =3D list_entry(cur, struct sedf_vcpu_info, list); - PRINT(4,"\tLooking @ dom %i.%i\n", - curinf->vcpu->domain->domain_id, curinf->vcpu->vcpu_id); if ( PERIOD_BEGIN(curinf) > now ) break; __del_from_queue(curinf->vcpu); __add_to_runqueue_sort(curinf->vcpu); } =20 - PRINT(3,"Updating runq..\n"); - - /* Process the runq, find domains that are on the runq that shouldn't.= */ + /* Process the runq, find domains that are on the runq that shouldn't = */ list_for_each_safe ( cur, tmp, runq ) { curinf =3D list_entry(cur,struct sedf_vcpu_info,list); - PRINT(4,"\tLooking @ dom %i.%i\n", - curinf->vcpu->domain->domain_id, curinf->vcpu->vcpu_id); =20 if ( unlikely(curinf->slice =3D=3D 0) ) { - /* Ignore domains with empty slice. */ - PRINT(4,"\tUpdating zero-slice domain %i.%i\n", - curinf->vcpu->domain->domain_id, - curinf->vcpu->vcpu_id); + /* Ignore domains with empty slice */ __del_from_queue(curinf->vcpu); =20 - /* Move them to their next period. */ + /* Move them to their next period */ curinf->deadl_abs +=3D curinf->period; =20 - /* Ensure that the start of the next period is in the future. = */ + /* Ensure that the start of the next period is in the future *= / if ( unlikely(PERIOD_BEGIN(curinf) < now) ) curinf->deadl_abs +=3D=20 (DIV_UP(now - PERIOD_BEGIN(curinf), curinf->period)) * curinf->period; =20 - /* Put them back into the queue. */ + /* Put them back into the queue */ __add_to_waitqueue_sort(curinf->vcpu); } else if ( unlikely((curinf->deadl_abs < now) || @@ -571,18 +518,18 @@ static void update_queues( * We missed the deadline or the slice was already finished. * Might hapen because of dom_adj. */ - PRINT(4,"\tDomain %i.%i exceeded it's deadline/" - "slice (%"PRIu64" / %"PRIu64") now: %"PRIu64 - " cputime: %"PRIu64"\n", - curinf->vcpu->domain->domain_id, - curinf->vcpu->vcpu_id, - curinf->deadl_abs, curinf->slice, now, - curinf->cputime); + printk("\tDomain %i.%i exceeded it's deadline/" + "slice (%"PRIu64" / %"PRIu64") now: %"PRIu64 + " cputime: %"PRIu64"\n", + curinf->vcpu->domain->domain_id, + curinf->vcpu->vcpu_id, + curinf->deadl_abs, curinf->slice, now, + curinf->cputime); __del_from_queue(curinf->vcpu); =20 - /* Common case: we miss one period. */ + /* Common case: we miss one period */ curinf->deadl_abs +=3D curinf->period; - =20 + /* * If we are still behind: modulo arithmetic, force deadline * to be in future and aligned to period borders. @@ -593,7 +540,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); @@ -603,17 +550,17 @@ static void update_queues( else break; } - - PRINT(3,"done updating the queues\n"); } =20 =20 -/* removes a domain from the head of the according extraQ and - requeues it at a specified position: - round-robin extratime: end of extraQ - weighted ext.: insert in sorted list by score - if the domain is blocked / has regained its short-block-loss - time it is not put on any queue */ +/* + * removes a domain from the head of the according extraQ and + * requeues it at a specified position: + * round-robin extratime: end of extraQ + * weighted ext.: insert in sorted list by score + * if the domain is blocked / has regained its short-block-loss + * time it is not put on any queue. + */ static void desched_extra_dom(s_time_t now, struct vcpu *d) { struct sedf_vcpu_info *inf =3D EDOM_INFO(d); @@ -622,29 +569,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 @@ -653,51 +596,59 @@ static void desched_extra_dom(s_time_t n if ( inf->short_block_lost_tot <=3D 0 ) #endif { - PRINT(4,"Domain %i.%i compensated short block loss!\n", - inf->vcpu->domain->domain_id, inf->vcpu->vcpu_id); - /*we have (over-)compensated our block penalty*/ + /* We have (over-)compensated our block penalty */ inf->short_block_lost_tot =3D 0; - /*we don't want a place on the penalty queue anymore!*/ + /* We don't want a place on the penalty queue anymore! */ inf->status &=3D ~EXTRA_WANT_PEN_Q; goto check_extra_queues; } =20 - /*we have to go again for another try in the block-extraq, - the score is not used incremantally here, as this is - already done by recalculating the block_lost*/ + /* + * We have to go again for another try in the block-extraq, + * the score is not used incremantally here, as this is + * already done by recalculating the block_lost + */ inf->score[EXTRA_PEN_Q] =3D (inf->period << 10) / inf->short_block_lost_tot; oldscore =3D 0; } else { - /*domain was running in L1 extraq =3D> score is inverse of - utilization and is used somewhat incremental!*/ + /* + * Domain was running in L1 extraq =3D> score is inverse of + * utilization and is used somewhat incremental! + */ if ( !inf->extraweight ) - /*NB: use fixed point arithmetic with 10 bits*/ + { + /* NB: use fixed point arithmetic with 10 bits */ inf->score[EXTRA_UTIL_Q] =3D (inf->period << 10) / inf->slice; + } else - /*conversion between realtime utilisation and extrawieght: - full (ie 100%) utilization is equivalent to 128 extraweight*= / + { + /* + * Conversion between realtime utilisation and extrawieght: + * full (ie 100%) utilization is equivalent to 128 extraweight + */ inf->score[EXTRA_UTIL_Q] =3D (1<<17) / inf->extraweight; + } } =20 check_extra_queues: - /* Adding a runnable domain to the right queue and removing blocked on= es*/ + /* Adding a runnable domain to the right queue and removing blocked on= es */ if ( sedf_runnable(d) ) { - /*add according to score: weighted round robin*/ + /* Add according to score: weighted round robin */ if (((inf->status & EXTRA_AWARE) && (i =3D=3D EXTRA_UTIL_Q)) || ((inf->status & EXTRA_WANT_PEN_Q) && (i =3D=3D EXTRA_PEN_Q))) extraq_add_sort_update(d, i, oldscore); } else { - /*remove this blocked domain from the waitq!*/ + /* Remove this blocked domain from the waitq! */ __del_from_queue(d); - /*make sure that we remove a blocked domain from the other - extraq too*/ + /* Make sure that we remove a blocked domain from the other + * extraq too. */ if ( i =3D=3D EXTRA_PEN_Q ) { if ( extraq_on(d, EXTRA_UTIL_Q) ) @@ -729,8 +680,10 @@ static struct task_slice sedf_do_extra_s =20 if ( !list_empty(extraq[EXTRA_PEN_Q]) ) { - /*we still have elements on the level 0 extraq=20 - =3D> let those run first!*/ + /* + * We still have elements on the level 0 extraq + * =3D> let those run first! + */ runinf =3D list_entry(extraq[EXTRA_PEN_Q]->next,=20 struct sedf_vcpu_info, extralist[EXTRA_PEN_Q= ]); runinf->status |=3D EXTRA_RUN_PEN; @@ -744,7 +697,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]); @@ -794,11 +747,13 @@ static void sedf_deinit(const struct sch } =20 =20 -/* Main scheduling function - Reasons for calling this function are: - -timeslice for the current period used up - -domain on waitqueue has started it's period - -and various others ;) in general: determine which domain to run next*/ +/* + * Main scheduling function + * Reasons for calling this function are: + * -timeslice for the current period used up + * -domain on waitqueue has started it's period + * -and various others ;) in general: determine which domain to run next + */ static struct task_slice sedf_do_schedule( const struct scheduler *ops, s_time_t now, bool_t tasklet_work_schedul= ed) { @@ -811,13 +766,15 @@ static struct task_slice sedf_do_schedul struct sedf_vcpu_info *runinf, *waitinf; struct task_slice ret; =20 - /*idle tasks don't need any of the following stuf*/ + /* Idle tasks don't need any of the following stuf */ if ( is_idle_vcpu(current) ) goto check_waitq; -=20 - /* create local state of the status of the domain, in order to avoid - inconsistent state during scheduling decisions, because data for - vcpu_runnable is not protected by the scheduling lock!*/ + + /* + * Create local state of the status of the domain, in order to avoid + * inconsistent state during scheduling decisions, because data for + * vcpu_runnable is not protected by the scheduling lock! + */ if ( !vcpu_runnable(current) ) inf->status |=3D SEDF_ASLEEP; =20 @@ -826,7 +783,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 @@ -836,10 +793,12 @@ static struct task_slice sedf_do_schedul check_waitq: update_queues(now, runq, waitq); =20 - /*now simply pick the first domain from the runqueue, which has the - earliest deadline, because the list is sorted*/ -=20 - /* Tasklet work (which runs in idle VCPU context) overrides all else. = */ + /* + * Now simply pick the first domain from the runqueue, which has the + * earliest deadline, because the list is sorted + * + * Tasklet work (which runs in idle VCPU context) overrides all else. + */ if ( tasklet_work_scheduled || (list_empty(runq) && list_empty(waitq)) || unlikely(!cpumask_test_cpu(cpu, SEDF_CPUONLINE(per_cpu(cpupool, c= pu)))) ) @@ -855,9 +814,11 @@ static struct task_slice sedf_do_schedul { waitinf =3D list_entry(waitq->next, struct sedf_vcpu_info,list); - /*rerun scheduler, when scheduled domain reaches it's - end of slice or the first domain from the waitqueue - gets ready*/ + /* + * Rerun scheduler, when scheduled domain reaches it's + * end of slice or the first domain from the waitqueue + * gets ready. + */ ret.time =3D MIN(now + runinf->slice - runinf->cputime, PERIOD_BEGIN(waitinf)) - now; } @@ -869,14 +830,18 @@ static struct task_slice sedf_do_schedul else { waitinf =3D list_entry(waitq->next,struct sedf_vcpu_info, list); - /*we could not find any suitable domain=20 - =3D> look for domains that are aware of extratime*/ + /* + * We could not find any suitable domain=20 + * =3D> look for domains that are aware of extratime + */ ret =3D sedf_do_extra_schedule(now, PERIOD_BEGIN(waitinf), extraq, cpu); } =20 - /*TODO: Do something USEFUL when this happens and find out, why it - still can happen!!!*/ + /* + * TODO: Do something USEFUL when this happens and find out, why it + * still can happen!!! + */ if ( ret.time < 0) { printk("Ouch! We are seriously BEHIND schedule! %"PRIi64"\n", @@ -896,9 +861,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 @@ -920,7 +882,8 @@ static void sedf_sleep(const struct sche } =20 =20 -/* This function wakes up a domain, i.e. moves them into the waitqueue +/* + * This function wakes up a domain, i.e. moves them into the waitqueue * things to mention are: admission control is taking place nowhere at * the moment, so we can't be sure, whether it is safe to wake the domain * up at all. Anyway, even if it is safe (total cpu usage <=3D100%) there = are @@ -994,27 +957,31 @@ static void sedf_sleep(const struct sche static void unblock_short_extra_support( struct sedf_vcpu_info* inf, s_time_t now) { - /*this unblocking scheme tries to support the domain, by assigning it - a priority in extratime distribution according to the loss of time - in this slice due to blocking*/ + /* + * This unblocking scheme tries to support the domain, by assigning it + * a priority in extratime distribution according to the loss of time + * in this slice due to blocking + */ s_time_t pen; =20 - /*no more realtime execution in this period!*/ + /* No more realtime execution in this period! */ inf->deadl_abs +=3D inf->period; if ( likely(inf->block_abs) ) { - //treat blocked time as consumed by the domain*/ + /* Treat blocked time as consumed by the domain */ /*inf->cputime +=3D now - inf->block_abs;*/ - /*penalty is time the domain would have - had if it continued to run */ + /* + * Penalty is time the domain would have + * had if it continued to run. + */ pen =3D (inf->slice - inf->cputime); if ( pen < 0 ) pen =3D 0; - /*accumulate all penalties over the periods*/ + /* Accumulate all penalties over the periods */ /*inf->short_block_lost_tot +=3D pen;*/ - /*set penalty to the current value*/ + /* Set penalty to the current value */ inf->short_block_lost_tot =3D pen; - /*not sure which one is better.. but seems to work well...*/ + /* Not sure which one is better.. but seems to work well... */ =20 if ( inf->short_block_lost_tot ) { @@ -1024,28 +991,31 @@ static void unblock_short_extra_support( inf->pen_extra_blocks++; #endif if ( extraq_on(inf->vcpu, EXTRA_PEN_Q) ) - /*remove domain for possible resorting!*/ + /* Remove domain for possible resorting! */ extraq_del(inf->vcpu, EXTRA_PEN_Q); else - /*remember that we want to be on the penalty q - so that we can continue when we (un-)block - in penalty-extratime*/ + /* + * Remember that we want to be on the penalty q + * so that we can continue when we (un-)block + * in penalty-extratime + */ inf->status |=3D EXTRA_WANT_PEN_Q; =20 - /*(re-)add domain to the penalty extraq*/ + /* (re-)add domain to the penalty extraq */ extraq_add_sort_update(inf->vcpu, EXTRA_PEN_Q, 0); } } =20 - /*give it a fresh slice in the next period!*/ + /* Give it a fresh slice in the next period! */ inf->cputime =3D 0; } =20 =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; } @@ -1068,15 +1038,17 @@ static inline int get_run_type(struct vc } =20 =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) @@ -1085,26 +1057,25 @@ static inline int should_switch(struct v cur_inf =3D EDOM_INFO(cur); other_inf =3D EDOM_INFO(other); =20 - /* Check whether we need to make an earlier scheduling decision. */ + /* Check whether we need to make an earlier scheduling decision */ if ( PERIOD_BEGIN(other_inf) <=20 CPU_INFO(other->processor)->current_slice_expires ) return 1; =20 - /* No timing-based switches need to be taken into account here. */ + /* No timing-based switches need to be taken into account here */ switch ( get_run_type(cur) ) { case DOMAIN_EDF: - /* Do not interrupt a running EDF domain. */ + /* Do not interrupt a running EDF domain */ return 0; case DOMAIN_EXTRA_PEN: - /* Check whether we also want the L0 ex-q with lower score. */ + /* Check whether we also want the L0 ex-q with lower score */ return ((other_inf->status & EXTRA_WANT_PEN_Q) && (other_inf->score[EXTRA_PEN_Q] <=20 cur_inf->score[EXTRA_PEN_Q])); case DOMAIN_EXTRA_UTIL: /* Check whether we want the L0 extraq. Don't - * switch if both domains want L1 extraq. - */ + * switch if both domains want L1 extraq. */ return !!(other_inf->status & EXTRA_WANT_PEN_Q); case DOMAIN_IDLE: return 1; @@ -1118,18 +1089,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; @@ -1138,28 +1102,25 @@ static void sedf_wake(const struct sched =20 if ( unlikely(inf->deadl_abs =3D=3D 0) ) { - /*initial setup of the deadline*/ + /* Initial setup of the deadline */ inf->deadl_abs =3D now + inf->slice; } =20 - PRINT(3, "waking up domain %i.%i (deadl=3D %"PRIu64" period=3D %"PRIu6= 4 - "now=3D %"PRIu64")\n", - d->domain->domain_id, d->vcpu_id, inf->deadl_abs, inf->period, n= ow); - #ifdef SEDF_STATS=20 inf->block_tot++; #endif =20 if ( unlikely(now < PERIOD_BEGIN(inf)) ) { - PRINT(4,"extratime unblock\n"); - /* unblocking in extra-time! */ + /* Unblocking in extra-time! */ if ( inf->status & EXTRA_WANT_PEN_Q ) { - /*we have a domain that wants compensation - for block penalty and did just block in - its compensation time. Give it another - chance!*/ + /* + * We have a domain that wants compensation + * for block penalty and did just block in + * its compensation time. Give it another + * chance! + */ extraq_add_sort_update(d, EXTRA_PEN_Q, 0); } extraq_check_add_unblocked(d, 0); @@ -1168,8 +1129,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 @@ -1179,8 +1139,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 @@ -1190,24 +1149,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; @@ -1216,12 +1164,14 @@ static void sedf_wake(const struct sched } #endif =20 - /*sanity check: make sure each extra-aware domain IS on the util-q!*/ + /* Sanity check: make sure each extra-aware domain IS on the util-q! *= / ASSERT(IMPLY(inf->status & EXTRA_AWARE, extraq_on(d, EXTRA_UTIL_Q))); ASSERT(__task_on_queue(d)); - /*check whether the awakened task needs to invoke the do_schedule - routine. Try to avoid unnecessary runs but: - Save approximation: Always switch to scheduler!*/ + /* + * Check whether the awakened task needs to invoke the do_schedule + * routine. Try to avoid unnecessary runs but: + * Save approximation: Always switch to scheduler! + */ ASSERT(d->processor >=3D 0); ASSERT(d->processor < nr_cpu_ids); ASSERT(per_cpu(schedule_data, d->processor).curr); @@ -1266,7 +1216,7 @@ static void sedf_dump_domain(struct vcpu } =20 =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; @@ -1341,16 +1291,18 @@ static void sedf_dump_cpu_state(const st } =20 =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, int nr_cpus, int *sumw, = s_time_t *sumt) { struct vcpu *p; struct domain *d; unsigned int cpu; =20 - /* Sum across all weights. Notice that no runq locking is needed + /* + * Sum across all weights. Notice that no runq locking is needed * here: the caller holds sedf_priv_info.lock and we're not changing - * anything that is accessed during scheduling. */ + * anything that is accessed during scheduling. + */ rcu_read_lock(&domlist_read_lock); for_each_domain_in_cpupool( d, c ) { @@ -1365,11 +1317,14 @@ static int sedf_adjust_weights(struct cp } else { - /*don't modify domains who don't have a weight, but sum - up the time they need, projected to a WEIGHT_PERIOD, - so that this time is not given to the weight-driven - domains*/ - /*check for overflows*/ + /* + * Don't modify domains who don't have a weight, but sum + * up the time they need, projected to a WEIGHT_PERIOD, + * so that this time is not given to the weight-driven + * domains + */ + + /* Check for overflows */ ASSERT((WEIGHT_PERIOD < ULONG_MAX)=20 && (EDOM_INFO(p)->slice_orig < ULONG_MAX)); sumt[cpu] +=3D=20 @@ -1380,9 +1335,11 @@ static int sedf_adjust_weights(struct cp } rcu_read_unlock(&domlist_read_lock); =20 - /* Adjust all slices (and periods) to the new weight. Unlike above, we + /* + * Adjust all slices (and periods) to the new weight. Unlike above, we * need to take thr runq lock for the various VCPUs: we're modyfing - * slice and period which are referenced during scheduling. */ + * slice and period which are referenced during scheduling. + */ rcu_read_lock(&domlist_read_lock); for_each_domain_in_cpupool( d, c ) { @@ -1410,7 +1367,7 @@ static int sedf_adjust_weights(struct cp } =20 =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 sedf_priv_info *prv =3D SEDF_PRIV(ops); @@ -1421,23 +1378,22 @@ static int sedf_adjust(const struct sche struct vcpu *v; int rc =3D 0; =20 - PRINT(2,"sedf_adjust was called, domain-id %i new period %"PRIu64" " - "new slice %"PRIu64"\nlatency %"PRIu64" extra:%s\n", - p->domain_id, op->u.sedf.period, op->u.sedf.slice, - op->u.sedf.latency, (op->u.sedf.extratime)?"yes":"no"); - - /* Serialize against the pluggable scheduler lock to protect from + /* + * Serialize against the pluggable scheduler lock to protect from * concurrent updates. We need to take the runq lock for the VCPUs * as well, since we are touching extraweight, weight, slice and * period. As in sched_credit2.c, runq locks nest inside the - * pluggable scheduler lock. */ + * pluggable scheduler lock. + */ spin_lock_irqsave(&prv->lock, flags); =20 if ( op->cmd =3D=3D XEN_DOMCTL_SCHEDOP_putinfo ) { - /* These are used in sedf_adjust_weights() but have to be allocate= d in + /* + * These are used in sedf_adjust_weights() but have to be allocate= d in * this function, as we need to avoid nesting xmem_pool_alloc's lo= ck - * within our prv->lock. */ + * within our prv->lock. + */ if ( !sumw || !sumt ) { /* Check for errors here, the _getinfo branch doesn't care */ @@ -1445,7 +1401,7 @@ static int sedf_adjust(const struct sche goto out; } =20 - /* Check for sane parameters. */ + /* Check for sane parameters */ if ( !op->u.sedf.period && !op->u.sedf.weight ) { rc =3D -EINVAL; @@ -1457,7 +1413,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 ) { /* (Here and everywhere in the following) IRQs are alr= eady off, @@ -1472,7 +1428,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 ) { vcpu_schedule_lock(v); EDOM_INFO(v)->weight =3D op->u.sedf.weight; @@ -1495,7 +1451,7 @@ static int sedf_adjust(const struct sche goto out; } =20 - /* Time-driven domains. */ + /* Time-driven domains */ for_each_vcpu ( p, v ) { vcpu_schedule_lock(v); @@ -1545,7 +1501,6 @@ out: xfree(sumt); xfree(sumw); =20 - PRINT(2,"sedf_adjust_finished with return code %d\n", rc); return rc; } =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) --=-Q+nO0nZUPH9ih0IDSLo0 Content-Disposition: attachment; filename="sedf-debug-cleanup.patch" Content-Transfer-Encoding: base64 Content-Type: text/x-patch; name="sedf-debug-cleanup.patch"; charset="UTF-8" IyBIRyBjaGFuZ2VzZXQgcGF0Y2gNCiMgUGFyZW50IGVmYWEyODYzOWE3MTUyNGE2OTNiYTUwMDYy NGY4NTEyZTU3OTVlMTgNCnNlZGY6IHJlbW92ZSB1c2VsZXNzIHRyYWNpbmcgcHJpbnRrIGFuZCBo YXJtb25pemUgY29tbWVudHMgc3R5bGUuDQoNCnNjaGVkX3NlZGYuYyB1c2VkIG8gaGF2ZSBpdHMg b3duIG1lY2hhbmlzbSBmb3IgcHJvZHVjaW5nIHRyYWNpbmctYWxpa2UNCmtpbmQgb2YgaW5mb3Jt YXRpb24gKGRvbWFpbiBibG9jaywgd2FrZXVwLCBldGMuKS4gTm93YWRheXMsIHdpdGggYW4gZXZl bg0Kbm90IHNvIGhpZ2ggbnVtYmVyIG9mIHBDUFVzL3ZDUFVzLCBqdXN0IHRyeWluZyB0byBlbmFi bGUgdGhpcyBtYWtlcw0KdGhlIHNlcmlhbCBjb25zb2xlIGNvbXBsZXRlbHkgdW51c2FibGUsIHBy b2R1Y2VzIHRvbnMgb2YgdmVyeSBoYXJkIHRvDQpwYXJzZSBhbmQgaW50ZXJwcmVldCBsb2dnaW5n IGFuZCBjYW4gZWFzaWx5IGxpdmVsb2NrIERvbTAuIE1vcmVvdmVyLA0KcHJldHR5IG11Y2ggdGhl IHNhbWUgcmVzdWx0IHRoaXMgaXMgc3RydWdnbGluZyB0byBnZXQgdG8sIGlzIGJldHRlcg0KYWNo aWV2ZWQgYnkgZW5hYmxpbmcgdGhlIHNjaGVkdWxlci1yZWxhdGVkIHRyYWNpbmcgZXZlbnRzLCBh cw0KaXQgaXMgZm9yIHRoZSBvdGhlciBzY2hlZHVsZXJzIChzYXksIGNyZWRpdCBvciBjcmVkaXQy KS4NCg0KRm9yIGFsbCB0aGVzZSByZWFzb25zLCB0aGlzIHJlbW92ZXMgdGhhdCBtYWNoaW5lcnkg Y29tcGxldGVseS4gV2hpbGUgYXQNCml0LCBjaGVjayBpbiBzb21lIGNvc21ldGljcyB0aGF0IGhh cm1vbml6ZSB0aGUgY29tbWVudHMgd2l0aGltIHRoZW1zZWxmDQphbmQgd2l0aCB0aGUgcmVzdCBv ZiB0aGUgY29kZSBiYXNlLg0KDQpTaWduZWQtb2ZmLWJ5OiBEYXJpbyBGYWdnaW9saSA8ZGFyaW8u ZmFnZ2lvbGlAY2l0cml4LmNvbT4NCg0KZGlmZiAtciBlZmFhMjg2MzlhNzEgeGVuL2NvbW1vbi9z Y2hlZF9zZWRmLmMNCi0tLSBhL3hlbi9jb21tb24vc2NoZWRfc2VkZi5jCVdlZCBKYW4gMDQgMTY6 MTI6NDQgMjAxMiArMDAwMA0KKysrIGIveGVuL2NvbW1vbi9zY2hlZF9zZWRmLmMJVGh1IEphbiAw NSAxNTowMjozMCAyMDEyICswMTAwDQpAQCAtMTMsMTQgKzEzLDYgQEANCiAjaW5jbHVkZSA8eGVu L3RpbWUuaD4NCiAjaW5jbHVkZSA8eGVuL2Vycm5vLmg+DQogDQotLyp2ZXJib3NpdHkgc2V0dGlu Z3MqLw0KLSNkZWZpbmUgU0VERkxFVkVMIDANCi0jZGVmaW5lIFBSSU5UKF9mLCBfYS4uLikgICAg ICAgICAgICAgICAgICAgICAgICBcDQotICAgIGRvIHsgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgXA0KLSAgICAgICAgaWYgKCAoX2YpIDw9IFNFREZMRVZFTCApICAgICAg ICAgICAgICAgIFwNCi0gICAgICAgICAgICBwcmludGsoX2EgKTsgICAgICAgICAgICAgICAgICAg ICAgICBcDQotICAgIH0gd2hpbGUgKCAwICkNCi0NCiAjZGVmaW5lIFNFREZfQ1BVT05MSU5FKF9w b29sKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwNCiAgICAg KCgoX3Bvb2wpID09IE5VTEwpID8gJmNwdXBvb2xfZnJlZV9jcHVzIDogKF9wb29sKS0+Y3B1X3Zh bGlkKQ0KIA0KQEAgLTcxLDM0ICs2MywzNSBAQCBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8gew0KICAg ICBzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7DQogICAgIHN0cnVjdCBsaXN0X2hlYWQgZXh0cmFsaXN0 WzJdOw0KICANCi0gICAgLypQYXJhbWV0ZXJzIGZvciBFREYqLw0KLSAgICBzX3RpbWVfdCAgcGVy aW9kOyAgLyo9KHJlbGF0aXZlIGRlYWRsaW5lKSovDQotICAgIHNfdGltZV90ICBzbGljZTsgIC8q PXdvcnN0IGNhc2UgZXhlY3V0aW9uIHRpbWUqLw0KKyAgICAvKiBQYXJhbWV0ZXJzIGZvciBFREYg Ki8NCisgICAgc190aW1lX3QgIHBlcmlvZDsgIC8qID0gcmVsYXRpdmUgZGVhZGxpbmUgKi8NCisg ICAgc190aW1lX3QgIHNsaWNlOyAgIC8qID0gd29yc3QgY2FzZSBleGVjdXRpb24gdGltZSAqLw0K ICANCi0gICAgLypBZHZhY2VkIFBhcmFtZXRlcnMqLw0KLSAgICAvKkxhdGVuY3kgU2NhbGluZyov DQorICAgIC8qIEFkdmFjZWQgUGFyYW1ldGVycyAqLw0KKw0KKyAgICAvKiBMYXRlbmN5IFNjYWxp bmcgKi8NCiAgICAgc190aW1lX3QgIHBlcmlvZF9vcmlnOw0KICAgICBzX3RpbWVfdCAgc2xpY2Vf b3JpZzsNCiAgICAgc190aW1lX3QgIGxhdGVuY3k7DQogIA0KLSAgICAvKnN0YXR1cyBvZiBkb21h aW4qLw0KKyAgICAvKiBTdGF0dXMgb2YgZG9tYWluICovDQogICAgIGludCAgICAgICBzdGF0dXM7 DQotICAgIC8qd2VpZ2h0cyBmb3IgIlNjaGVkdWxpbmcgZm9yIGJlZ2lubmVycy8gbGF6eS8gZXRj LiIgOykqLw0KKyAgICAvKiBXZWlnaHRzIGZvciAiU2NoZWR1bGluZyBmb3IgYmVnaW5uZXJzLyBs YXp5LyBldGMuIiA7KSAqLw0KICAgICBzaG9ydCAgICAgd2VpZ2h0Ow0KICAgICBzaG9ydCAgICAg ZXh0cmF3ZWlnaHQ7DQotICAgIC8qQm9va2tlZXBpbmcqLw0KKyAgICAvKiBCb29ra2VlcGluZyAq Lw0KICAgICBzX3RpbWVfdCAgZGVhZGxfYWJzOw0KICAgICBzX3RpbWVfdCAgc2NoZWRfc3RhcnRf YWJzOw0KICAgICBzX3RpbWVfdCAgY3B1dGltZTsNCi0gICAgLyogdGltZXMgdGhlIGRvbWFpbiB1 bi0vYmxvY2tlZCAqLw0KKyAgICAvKiBUaW1lcyB0aGUgZG9tYWluIHVuLS9ibG9ja2VkICovDQog ICAgIHNfdGltZV90ICBibG9ja19hYnM7DQogICAgIHNfdGltZV90ICB1bmJsb2NrX2FiczsNCiAg DQotICAgIC8qc2NvcmVzIGZvciB7dXRpbCwgYmxvY2sgcGVuYWx0eX0td2VpZ2h0ZWQgZXh0cmF0 aW1lIGRpc3RyaWJ1dGlvbiovDQorICAgIC8qIFNjb3JlcyBmb3Ige3V0aWwsIGJsb2NrIHBlbmFs dHl9LXdlaWdodGVkIGV4dHJhdGltZSBkaXN0cmlidXRpb24gKi8NCiAgICAgaW50ICAgc2NvcmVb Ml07DQogICAgIHNfdGltZV90ICBzaG9ydF9ibG9ja19sb3N0X3RvdDsNCiAgDQotICAgIC8qU3Rh dGlzdGljcyovDQorICAgIC8qIFN0YXRpc3RpY3MgKi8NCiAgICAgc190aW1lX3QgIGV4dHJhX3Rp bWVfdG90Ow0KIA0KICNpZmRlZiBTRURGX1NUQVRTDQpAQCAtMTY1LDE4ICsxNTgsMTcgQEAgc3Rh dGljIGlubGluZSB2b2lkIGV4dHJhcV9kZWwoc3RydWN0IHZjcA0KIHsNCiAgICAgc3RydWN0IGxp c3RfaGVhZCAqbGlzdCA9IEVYVFJBTElTVChkLGkpOw0KICAgICBBU1NFUlQoZXh0cmFxX29uKGQs aSkpOw0KLSAgICBQUklOVCgzLCAiUmVtb3ZpbmcgZG9tYWluICVpLiVpIGZyb20gTCVpIGV4dHJh cVxuIiwNCi0gICAgICAgICAgZC0+ZG9tYWluLT5kb21haW5faWQsIGQtPnZjcHVfaWQsIGkpOw0K ICAgICBsaXN0X2RlbChsaXN0KTsNCiAgICAgbGlzdC0+bmV4dCA9IE5VTEw7DQogICAgIEFTU0VS VCghZXh0cmFxX29uKGQsIGkpKTsNCiB9DQogDQotLyogYWRkcyBhIGRvbWFpbiB0byB0aGUgcXVl dWUgb2YgcHJvY2Vzc2VzIHdoaWNoIGFyZSBhd2FyZSBvZiBleHRyYSB0aW1lLiBMaXN0DQotICAg aXMgc29ydGVkIGJ5IHNjb3JlLCB3aGVyZSBhIGxvd2VyIHNjb3JlIG1lYW5zIGhpZ2hlciBwcmlv cml0eSBmb3IgYW4gZXh0cmENCi0gICBzbGljZS4gSXQgYWxzbyB1cGRhdGVzIHRoZSBzY29yZSwg Ynkgc2ltcGx5IHN1YnRyYWN0aW5nIGEgZml4ZWQgdmFsdWUgZnJvbQ0KLSAgIGVhY2ggZW50cnks IGluIG9yZGVyIHRvIGF2b2lkIG92ZXJmbG93LiBUaGUgYWxnb3JpdGhtIHdvcmtzIGJ5IHNpbXBs eQ0KLSAgIGNoYXJnaW5nIGVhY2ggZG9tYWluIHRoYXQgcmVjaWV2ZWQgZXh0cmF0aW1lIHdpdGgg YW4gaW52ZXJzZSBvZiBpdHMgd2VpZ2h0Lg0KKy8qDQorICogQWRkcyBhIGRvbWFpbiB0byB0aGUg cXVldWUgb2YgcHJvY2Vzc2VzIHdoaWNoIGFyZSBhd2FyZSBvZiBleHRyYSB0aW1lLiBMaXN0DQor ICogaXMgc29ydGVkIGJ5IHNjb3JlLCB3aGVyZSBhIGxvd2VyIHNjb3JlIG1lYW5zIGhpZ2hlciBw cmlvcml0eSBmb3IgYW4gZXh0cmENCisgKiBzbGljZS4gSXQgYWxzbyB1cGRhdGVzIHRoZSBzY29y ZSwgYnkgc2ltcGx5IHN1YnRyYWN0aW5nIGEgZml4ZWQgdmFsdWUgZnJvbQ0KKyAqIGVhY2ggZW50 cnksIGluIG9yZGVyIHRvIGF2b2lkIG92ZXJmbG93LiBUaGUgYWxnb3JpdGhtIHdvcmtzIGJ5IHNp bXBseQ0KKyAqIGNoYXJnaW5nIGVhY2ggZG9tYWluIHRoYXQgcmVjaWV2ZWQgZXh0cmF0aW1lIHdp dGggYW4gaW52ZXJzZSBvZiBpdHMgd2VpZ2h0Lg0KICAqLyANCiBzdGF0aWMgaW5saW5lIHZvaWQg ZXh0cmFxX2FkZF9zb3J0X3VwZGF0ZShzdHJ1Y3QgdmNwdSAqZCwgaW50IGksIGludCBzdWIpDQog ew0KQEAgLTE4NSwxMSArMTc3LDYgQEAgc3RhdGljIGlubGluZSB2b2lkIGV4dHJhcV9hZGRfc29y dF91cGRhdA0KICANCiAgICAgQVNTRVJUKCFleHRyYXFfb24oZCxpKSk7DQogDQotICAgIFBSSU5U KDMsICJBZGRpbmcgZG9tYWluICVpLiVpIChzY29yZT0gJWksIHNob3J0X3Blbj0gJSJQUklpNjQi KSINCi0gICAgICAgICAgIiB0byBMJWkgZXh0cmFxXG4iLA0KLSAgICAgICAgICBkLT5kb21haW4t PmRvbWFpbl9pZCwgZC0+dmNwdV9pZCwgRURPTV9JTkZPKGQpLT5zY29yZVtpXSwNCi0gICAgICAg ICAgRURPTV9JTkZPKGQpLT5zaG9ydF9ibG9ja19sb3N0X3RvdCwgaSk7DQotDQogICAgIC8qDQog ICAgICAqIEl0ZXJhdGUgdGhyb3VnaCBhbGwgZWxlbWVudHMgdG8gZmluZCBvdXIgImhvbGUiIGFu ZCBvbiBvdXIgd2F5DQogICAgICAqIHVwZGF0ZSBhbGwgdGhlIG90aGVyIHNjb3Jlcy4NCkBAIC0y MDAsMjUgKzE4NywxOCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZXh0cmFxX2FkZF9zb3J0X3VwZGF0 DQogICAgICAgICBjdXJpbmYtPnNjb3JlW2ldIC09IHN1YjsNCiAgICAgICAgIGlmICggRURPTV9J TkZPKGQpLT5zY29yZVtpXSA8IGN1cmluZi0+c2NvcmVbaV0gKQ0KICAgICAgICAgICAgIGJyZWFr Ow0KLSAgICAgICAgUFJJTlQoNCwiXHRiZWhpbmQgZG9tYWluICVpLiVpIChzY29yZT0gJWkpXG4i LA0KLSAgICAgICAgICAgICAgY3VyaW5mLT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwNCi0gICAg ICAgICAgICAgIGN1cmluZi0+dmNwdS0+dmNwdV9pZCwgY3VyaW5mLT5zY29yZVtpXSk7DQogICAg IH0NCiANCi0gICAgLyogY3VyIG5vdyBjb250YWlucyB0aGUgZWxlbWVudCwgYmVmb3JlIHdoaWNo IHdlJ2xsIGVucXVldWUuICovDQotICAgIFBSSU5UKDMsICJcdGxpc3RfYWRkIHRvICVwXG4iLCBj dXItPnByZXYpOw0KKyAgICAvKiBjdXIgbm93IGNvbnRhaW5zIHRoZSBlbGVtZW50LCBiZWZvcmUg d2hpY2ggd2UnbGwgZW5xdWV1ZSAqLw0KICAgICBsaXN0X2FkZChFWFRSQUxJU1QoZCxpKSxjdXIt PnByZXYpOw0KICANCi0gICAgLyogQ29udGludWUgdXBkYXRpbmcgdGhlIGV4dHJhcS4gKi8NCisg ICAgLyogQ29udGludWUgdXBkYXRpbmcgdGhlIGV4dHJhcSAqLw0KICAgICBpZiAoIChjdXIgIT0g RVhUUkFRKGQtPnByb2Nlc3NvcixpKSkgJiYgc3ViICkNCiAgICAgew0KICAgICAgICAgZm9yICgg Y3VyID0gY3VyLT5uZXh0OyBjdXIgIT0gRVhUUkFRKGQtPnByb2Nlc3NvcixpKTsgY3VyID0gY3Vy LT5uZXh0ICkNCiAgICAgICAgIHsNCiAgICAgICAgICAgICBjdXJpbmYgPSBsaXN0X2VudHJ5KGN1 cixzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8sIGV4dHJhbGlzdFtpXSk7DQogICAgICAgICAgICAgY3Vy aW5mLT5zY29yZVtpXSAtPSBzdWI7DQotICAgICAgICAgICAgUFJJTlQoNCwgIlx0dXBkYXRpbmcg ZG9tYWluICVpLiVpIChzY29yZT0gJXUpXG4iLA0KLSAgICAgICAgICAgICAgICAgIGN1cmluZi0+ dmNwdS0+ZG9tYWluLT5kb21haW5faWQsIA0KLSAgICAgICAgICAgICAgICAgIGN1cmluZi0+dmNw dS0+dmNwdV9pZCwgY3VyaW5mLT5zY29yZVtpXSk7DQogICAgICAgICB9DQogICAgIH0NCiANCkBA IC0yMjgsMjkgKzIwOCwxNCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZXh0cmFxX2NoZWNrKHN0cnVj dCB2DQogew0KICAgICBpZiAoIGV4dHJhcV9vbihkLCBFWFRSQV9VVElMX1EpICkNCiAgICAgew0K LSAgICAgICAgUFJJTlQoMiwiRG9tICVpLiVpIGlzIG9uIEwxIGV4dHJhUVxuIiwNCi0gICAgICAg ICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBkLT52Y3B1X2lkKTsNCi0NCiAgICAgICAgIGlm ICggIShFRE9NX0lORk8oZCktPnN0YXR1cyAmIEVYVFJBX0FXQVJFKSAmJg0KICAgICAgICAgICAg ICAhZXh0cmFfcnVucyhFRE9NX0lORk8oZCkpICkNCi0gICAgICAgIHsNCiAgICAgICAgICAgICBl eHRyYXFfZGVsKGQsIEVYVFJBX1VUSUxfUSk7DQotICAgICAgICAgICAgUFJJTlQoMiwiUmVtb3Zl ZCBkb20gJWkuJWkgZnJvbSBMMSBleHRyYVFcbiIsDQotICAgICAgICAgICAgICAgICAgZC0+ZG9t YWluLT5kb21haW5faWQsIGQtPnZjcHVfaWQpOw0KLSAgICAgICAgfQ0KICAgICB9DQogICAgIGVs c2UNCiAgICAgew0KLSAgICAgICAgUFJJTlQoMiwgIkRvbSAlaS4laSBpcyBOT1Qgb24gTDEgZXh0 cmFRXG4iLA0KLSAgICAgICAgICAgICAgZC0+ZG9tYWluLT5kb21haW5faWQsDQotICAgICAgICAg ICAgICBkLT52Y3B1X2lkKTsNCi0NCiAgICAgICAgIGlmICggKEVET01fSU5GTyhkKS0+c3RhdHVz ICYgRVhUUkFfQVdBUkUpICYmIHNlZGZfcnVubmFibGUoZCkgKQ0KLSAgICAgICAgew0KICAgICAg ICAgICAgIGV4dHJhcV9hZGRfc29ydF91cGRhdGUoZCwgRVhUUkFfVVRJTF9RLCAwKTsNCi0gICAg ICAgICAgICBQUklOVCgyLCJBZGRlZCBkb20gJWkuJWkgdG8gTDEgZXh0cmFRXG4iLA0KLSAgICAg ICAgICAgICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBkLT52Y3B1X2lkKTsNCi0gICAgICAg IH0NCiAgICAgfQ0KIH0NCiANCkBAIC0yNTksNyArMjI0LDcgQEAgc3RhdGljIGlubGluZSB2b2lk IGV4dHJhcV9jaGVja19hZGRfdW5ibA0KICAgICBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8gKmluZiA9 IEVET01fSU5GTyhkKTsNCiANCiAgICAgaWYgKCBpbmYtPnN0YXR1cyAmIEVYVFJBX0FXQVJFICkN Ci0gICAgICAgIC8qIFB1dCBvbiB0aGUgd2VpZ2h0ZWQgZXh0cmFxIHdpdGhvdXQgdXBkYXRpbmcg YW55IHNjb3Jlcy4gKi8NCisgICAgICAgIC8qIFB1dCBvbiB0aGUgd2VpZ2h0ZWQgZXh0cmFxIHdp dGhvdXQgdXBkYXRpbmcgYW55IHNjb3JlcyAqLw0KICAgICAgICAgZXh0cmFxX2FkZF9zb3J0X3Vw ZGF0ZShkLCBFWFRSQV9VVElMX1EsIDApOw0KIH0NCiANCkBAIC0yNzIsOCArMjM3LDYgQEAgc3Rh dGljIGlubGluZSB2b2lkIF9fZGVsX2Zyb21fcXVldWUoc3RydQ0KIHsNCiAgICAgc3RydWN0IGxp c3RfaGVhZCAqbGlzdCA9IExJU1QoZCk7DQogICAgIEFTU0VSVChfX3Rhc2tfb25fcXVldWUoZCkp Ow0KLSAgICBQUklOVCgzLCJSZW1vdmluZyBkb21haW4gJWkuJWkgKGJvcD0gJSJQUkl1NjQiKSBm cm9tIHJ1bnEvd2FpdHFcbiIsDQotICAgICAgICAgIGQtPmRvbWFpbi0+ZG9tYWluX2lkLCBkLT52 Y3B1X2lkLCBQRVJJT0RfQkVHSU4oRURPTV9JTkZPKGQpKSk7DQogICAgIGxpc3RfZGVsKGxpc3Qp Ow0KICAgICBsaXN0LT5uZXh0ID0gTlVMTDsNCiAgICAgQVNTRVJUKCFfX3Rhc2tfb25fcXVldWUo ZCkpOw0KQEAgLTI4NiwxMyArMjQ5LDEyIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBsaXN0X2luc2Vy dF9zb3J0KA0KIHsNCiAgICAgc3RydWN0IGxpc3RfaGVhZCAgICAgKmN1cjsNCiANCi0gICAgLyog SXRlcmF0ZSB0aHJvdWdoIGFsbCBlbGVtZW50cyB0byBmaW5kIG91ciAiaG9sZSIuICovDQorICAg IC8qIEl0ZXJhdGUgdGhyb3VnaCBhbGwgZWxlbWVudHMgdG8gZmluZCBvdXIgImhvbGUiICovDQog ICAgIGxpc3RfZm9yX2VhY2goIGN1ciwgbGlzdCApDQogICAgICAgICBpZiAoIGNvbXAoZWxlbWVu dCwgY3VyKSA8IDAgKQ0KICAgICAgICAgICAgIGJyZWFrOw0KIA0KLSAgICAvKiBjdXIgbm93IGNv bnRhaW5zIHRoZSBlbGVtZW50LCBiZWZvcmUgd2hpY2ggd2UnbGwgZW5xdWV1ZS4gKi8NCi0gICAg UFJJTlQoMywiXHRsaXN0X2FkZCB0byAlcFxuIixjdXItPnByZXYpOw0KKyAgICAvKiBjdXIgbm93 IGNvbnRhaW5zIHRoZSBlbGVtZW50LCBiZWZvcmUgd2hpY2ggd2UnbGwgZW5xdWV1ZSAqLw0KICAg ICBsaXN0X2FkZChlbGVtZW50LCBjdXItPnByZXYpOw0KIH0NCiANCkBAIC0zMTAsMzAgKzI3Miwy OCBAQCBzdGF0aWMgaW50IG5hbWUjI19jb21wKHN0cnVjdCBsaXN0X2hlYWQqDQogICAgICAgICBy ZXR1cm4gMTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgXA0KIH0NCiANCi0vKiBhZGRzIGEgZG9tYWluIHRvIHRoZSBxdWV1ZSBvZiBwcm9jZXNz ZXMgd2hpY2ggd2FpdCBmb3IgdGhlIGJlZ2lubmluZyBvZiB0aGUNCi0gICBuZXh0IHBlcmlvZDsg dGhpcyBsaXN0IGlzIHRoZXJlZm9yZSBzb3J0ZXQgYnkgdGhpcyB0aW1lLCB3aGljaCBpcyBzaW1w bHkNCi0gICBhYnNvbC4gZGVhZGxpbmUgLSBwZXJpb2QNCisvKg0KKyAqIEFkZHMgYSBkb21haW4g dG8gdGhlIHF1ZXVlIG9mIHByb2Nlc3NlcyB3aGljaCB3YWl0IGZvciB0aGUgYmVnaW5uaW5nIG9m IHRoZQ0KKyAqIG5leHQgcGVyaW9kOyB0aGlzIGxpc3QgaXMgdGhlcmVmb3JlIHNvcnRldCBieSB0 aGlzIHRpbWUsIHdoaWNoIGlzIHNpbXBseQ0KKyAqIGFic29sLiBkZWFkbGluZSAtIHBlcmlvZC4N CiAgKi8gDQogRE9NQUlOX0NPTVBBUkVSKHdhaXRxLCBsaXN0LCBQRVJJT0RfQkVHSU4oZDEpLCBQ RVJJT0RfQkVHSU4oZDIpKTsNCiBzdGF0aWMgaW5saW5lIHZvaWQgX19hZGRfdG9fd2FpdHF1ZXVl X3NvcnQoc3RydWN0IHZjcHUgKnYpDQogew0KICAgICBBU1NFUlQoIV9fdGFza19vbl9xdWV1ZSh2 KSk7DQotICAgIFBSSU5UKDMsIkFkZGluZyBkb21haW4gJWkuJWkgKGJvcD0gJSJQUkl1NjQiKSB0 byB3YWl0cVxuIiwNCi0gICAgICAgICAgdi0+ZG9tYWluLT5kb21haW5faWQsIHYtPnZjcHVfaWQs IFBFUklPRF9CRUdJTihFRE9NX0lORk8odikpKTsNCiAgICAgbGlzdF9pbnNlcnRfc29ydChXQUlU USh2LT5wcm9jZXNzb3IpLCBMSVNUKHYpLCB3YWl0cV9jb21wKTsNCiAgICAgQVNTRVJUKF9fdGFz a19vbl9xdWV1ZSh2KSk7DQogfQ0KIA0KLS8qIGFkZHMgYSBkb21haW4gdG8gdGhlIHF1ZXVlIG9m IHByb2Nlc3NlcyB3aGljaCBoYXZlIHN0YXJ0ZWQgdGhlaXIgY3VycmVudA0KLSAgIHBlcmlvZCBh bmQgYXJlIHJ1bm5hYmxlIChpLmUuIG5vdCBibG9ja2VkLCBkaWVpbmcsLi4uKS4gVGhlIGZpcnN0 IGVsZW1lbnQNCi0gICBvbiB0aGlzIGxpc3QgaXMgcnVubmluZyBvbiB0aGUgcHJvY2Vzc29yLCBp ZiB0aGUgbGlzdCBpcyBlbXB0eSB0aGUgaWRsZQ0KLSAgIHRhc2sgd2lsbCBydW4uIEFzIHdlIGFy ZSBpbXBsZW1lbnRpbmcgRURGLCB0aGlzIGxpc3QgaXMgc29ydGVkIGJ5IGRlYWRsaW5lcy4NCisv Kg0KKyAqIEFkZHMgYSBkb21haW4gdG8gdGhlIHF1ZXVlIG9mIHByb2Nlc3NlcyB3aGljaCBoYXZl IHN0YXJ0ZWQgdGhlaXIgY3VycmVudA0KKyAqIHBlcmlvZCBhbmQgYXJlIHJ1bm5hYmxlIChpLmUu IG5vdCBibG9ja2VkLCBkaWVpbmcsLi4uKS4gVGhlIGZpcnN0IGVsZW1lbnQNCisgKiBvbiB0aGlz IGxpc3QgaXMgcnVubmluZyBvbiB0aGUgcHJvY2Vzc29yLCBpZiB0aGUgbGlzdCBpcyBlbXB0eSB0 aGUgaWRsZQ0KKyAqIHRhc2sgd2lsbCBydW4uIEFzIHdlIGFyZSBpbXBsZW1lbnRpbmcgRURGLCB0 aGlzIGxpc3QgaXMgc29ydGVkIGJ5IGRlYWRsaW5lcy4NCiAgKi8gDQogRE9NQUlOX0NPTVBBUkVS KHJ1bnEsIGxpc3QsIGQxLT5kZWFkbF9hYnMsIGQyLT5kZWFkbF9hYnMpOw0KIHN0YXRpYyBpbmxp bmUgdm9pZCBfX2FkZF90b19ydW5xdWV1ZV9zb3J0KHN0cnVjdCB2Y3B1ICp2KQ0KIHsNCi0gICAg UFJJTlQoMywiQWRkaW5nIGRvbWFpbiAlaS4laSAoZGVhZGw9ICUiUFJJdTY0IikgdG8gcnVucVxu IiwNCi0gICAgICAgICAgdi0+ZG9tYWluLT5kb21haW5faWQsIHYtPnZjcHVfaWQsIEVET01fSU5G Tyh2KS0+ZGVhZGxfYWJzKTsNCiAgICAgbGlzdF9pbnNlcnRfc29ydChSVU5RKHYtPnByb2Nlc3Nv ciksIExJU1QodiksIHJ1bnFfY29tcCk7DQogfQ0KIA0KQEAgLTM2MSwxMiArMzIxLDEyIEBAIHN0 YXRpYyB2b2lkICpzZWRmX2FsbG9jX3ZkYXRhKGNvbnN0IHN0cnUNCiANCiAgICAgaW5mLT52Y3B1 ID0gdjsNCiANCi0gICAgLyogRXZlcnkgVkNQVSBnZXRzIGFuIGVxdWFsIHNoYXJlIG9mIGV4dHJh dGltZSBieSBkZWZhdWx0LiAqLw0KKyAgICAvKiBFdmVyeSBWQ1BVIGdldHMgYW4gZXF1YWwgc2hh cmUgb2YgZXh0cmF0aW1lIGJ5IGRlZmF1bHQgKi8NCiAgICAgaW5mLT5kZWFkbF9hYnMgICA9IDA7 DQogICAgIGluZi0+bGF0ZW5jeSAgICAgPSAwOw0KICAgICBpbmYtPnN0YXR1cyAgICAgID0gRVhU UkFfQVdBUkUgfCBTRURGX0FTTEVFUDsNCiAgICAgaW5mLT5leHRyYXdlaWdodCA9IDE7DQotICAg IC8qIFVwb24gY3JlYXRpb24gYWxsIGRvbWFpbiBhcmUgYmVzdC1lZmZvcnQuICovDQorICAgIC8q IFVwb24gY3JlYXRpb24gYWxsIGRvbWFpbiBhcmUgYmVzdC1lZmZvcnQgKi8NCiAgICAgaW5mLT5w ZXJpb2QgICAgICA9IFdFSUdIVF9QRVJJT0Q7DQogICAgIGluZi0+c2xpY2UgICAgICAgPSAwOw0K IA0KQEAgLTQ1MCwyMSArNDEwLDE5IEBAIHN0YXRpYyB2b2lkIGRlc2NoZWRfZWRmX2RvbShzX3Rp bWVfdCBub3cNCiB7DQogICAgIHN0cnVjdCBzZWRmX3ZjcHVfaW5mbyogaW5mID0gRURPTV9JTkZP KGQpOw0KIA0KLSAgICAvKiBDdXJyZW50IGRvbWFpbiBpcyBydW5uaW5nIGluIHJlYWwgdGltZSBt b2RlLiAqLw0KKyAgICAvKiBDdXJyZW50IGRvbWFpbiBpcyBydW5uaW5nIGluIHJlYWwgdGltZSBt b2RlICovDQogICAgIEFTU0VSVChfX3Rhc2tfb25fcXVldWUoZCkpOw0KIA0KLSAgICAvKiBVcGRh dGUgdGhlIGRvbWFpbidzIGNwdXRpbWUuICovDQorICAgIC8qIFVwZGF0ZSB0aGUgZG9tYWluJ3Mg Y3B1dGltZSAqLw0KICAgICBpbmYtPmNwdXRpbWUgKz0gbm93IC0gaW5mLT5zY2hlZF9zdGFydF9h YnM7DQogDQotICAgIC8qDQotICAgICAqIFNjaGVkdWxpbmcgZGVjaXNpb25zIHdoaWNoIGRvbid0 IHJlbW92ZSB0aGUgcnVubmluZyBkb21haW4gZnJvbSB0aGUNCi0gICAgICogcnVucS4gDQotICAg ICAqLw0KKyAgICAvKiBTY2hlZHVsaW5nIGRlY2lzaW9ucyB3aGljaCBkb24ndCByZW1vdmUgdGhl IHJ1bm5pbmcgZG9tYWluIGZyb20NCisgICAgICogdGhlIHJ1bnEgKi8NCiAgICAgaWYgKCAoaW5m LT5jcHV0aW1lIDwgaW5mLT5zbGljZSkgJiYgc2VkZl9ydW5uYWJsZShkKSApDQogICAgICAgICBy ZXR1cm47DQogICANCiAgICAgX19kZWxfZnJvbV9xdWV1ZShkKTsNCi0gIA0KKw0KICAgICAvKg0K ICAgICAgKiBNYW5hZ2UgYm9va2tlZXBpbmcgKGkuZS4gY2FsY3VsYXRlIG5leHQgZGVhZGxpbmUs IG1lbW9yaXNlDQogICAgICAqIG92ZXJydW4tdGltZSBvZiBzbGljZSkgb2YgZmluaXNoZWQgZG9t YWlucy4NCkBAIC00NzUsMzAgKzQzMywzMCBAQCBzdGF0aWMgdm9pZCBkZXNjaGVkX2VkZl9kb20o c190aW1lX3Qgbm93DQogICANCiAgICAgICAgIGlmICggaW5mLT5wZXJpb2QgPCBpbmYtPnBlcmlv ZF9vcmlnICkNCiAgICAgICAgIHsNCi0gICAgICAgICAgICAvKiBUaGlzIGRvbWFpbiBydW5zIGlu IGxhdGVuY3kgc2NhbGluZyBvciBidXJzdCBtb2RlLiAqLw0KKyAgICAgICAgICAgIC8qIFRoaXMg ZG9tYWluIHJ1bnMgaW4gbGF0ZW5jeSBzY2FsaW5nIG9yIGJ1cnN0IG1vZGUgKi8NCiAgICAgICAg ICAgICBpbmYtPnBlcmlvZCAqPSAyOw0KICAgICAgICAgICAgIGluZi0+c2xpY2UgICo9IDI7DQog ICAgICAgICAgICAgaWYgKCAoaW5mLT5wZXJpb2QgPiBpbmYtPnBlcmlvZF9vcmlnKSB8fA0KICAg ICAgICAgICAgICAgICAgKGluZi0+c2xpY2UgPiBpbmYtPnNsaWNlX29yaWcpICkNCiAgICAgICAg ICAgICB7DQotICAgICAgICAgICAgICAgIC8qIFJlc2V0IHNsaWNlIGFuZCBwZXJpb2QuICovDQor ICAgICAgICAgICAgICAgIC8qIFJlc2V0IHNsaWNlIGFuZCBwZXJpb2QgKi8NCiAgICAgICAgICAg ICAgICAgaW5mLT5wZXJpb2QgPSBpbmYtPnBlcmlvZF9vcmlnOw0KICAgICAgICAgICAgICAgICBp bmYtPnNsaWNlID0gaW5mLT5zbGljZV9vcmlnOw0KICAgICAgICAgICAgIH0NCiAgICAgICAgIH0N CiANCi0gICAgICAgIC8qIFNldCBuZXh0IGRlYWRsaW5lLiAqLw0KKyAgICAgICAgLyogU2V0IG5l eHQgZGVhZGxpbmUgKi8NCiAgICAgICAgIGluZi0+ZGVhZGxfYWJzICs9IGluZi0+cGVyaW9kOw0K ICAgICB9DQogIA0KLSAgICAvKiBBZGQgYSBydW5uYWJsZSBkb21haW4gdG8gdGhlIHdhaXRxdWV1 ZS4gKi8NCisgICAgLyogQWRkIGEgcnVubmFibGUgZG9tYWluIHRvIHRoZSB3YWl0cXVldWUgKi8N CiAgICAgaWYgKCBzZWRmX3J1bm5hYmxlKGQpICkNCiAgICAgew0KICAgICAgICAgX19hZGRfdG9f d2FpdHF1ZXVlX3NvcnQoZCk7DQogICAgIH0NCiAgICAgZWxzZQ0KICAgICB7DQotICAgICAgICAv KiBXZSBoYXZlIGEgYmxvY2tlZCByZWFsdGltZSB0YXNrIC0+IHJlbW92ZSBpdCBmcm9tIGV4cXMg dG9vLiAqLw0KKyAgICAgICAgLyogV2UgaGF2ZSBhIGJsb2NrZWQgcmVhbHRpbWUgdGFzayAtPiBy ZW1vdmUgaXQgZnJvbSBleHFzIHRvbyAqLw0KICAgICAgICAgaWYgKCBleHRyYXFfb24oZCwgRVhU UkFfUEVOX1EpICkNCiAgICAgICAgICAgICBleHRyYXFfZGVsKGQsIEVYVFJBX1BFTl9RKTsNCiAg ICAgICAgIGlmICggZXh0cmFxX29uKGQsIEVYVFJBX1VUSUxfUSkgKQ0KQEAgLTUxOCw4ICs0NzYs NiBAQCBzdGF0aWMgdm9pZCB1cGRhdGVfcXVldWVzKA0KICAgICBzdHJ1Y3QgbGlzdF9oZWFkICAg ICAqY3VyLCAqdG1wOw0KICAgICBzdHJ1Y3Qgc2VkZl92Y3B1X2luZm8gKmN1cmluZjsNCiAgDQot ICAgIFBSSU5UKDMsIlVwZGF0aW5nIHdhaXRxLi5cbiIpOw0KLQ0KICAgICAvKg0KICAgICAgKiBD aGVjayBmb3IgdGhlIGZpcnN0IGVsZW1lbnRzIG9mIHRoZSB3YWl0cXVldWUsIHdoZXRoZXIgdGhl aXINCiAgICAgICogbmV4dCBwZXJpb2QgaGFzIGFscmVhZHkgc3RhcnRlZC4NCkBAIC01MjcsNDEg KzQ4MywzMiBAQCBzdGF0aWMgdm9pZCB1cGRhdGVfcXVldWVzKA0KICAgICBsaXN0X2Zvcl9lYWNo X3NhZmUgKCBjdXIsIHRtcCwgd2FpdHEgKQ0KICAgICB7DQogICAgICAgICBjdXJpbmYgPSBsaXN0 X2VudHJ5KGN1ciwgc3RydWN0IHNlZGZfdmNwdV9pbmZvLCBsaXN0KTsNCi0gICAgICAgIFBSSU5U KDQsIlx0TG9va2luZyBAIGRvbSAlaS4laVxuIiwNCi0gICAgICAgICAgICAgIGN1cmluZi0+dmNw dS0+ZG9tYWluLT5kb21haW5faWQsIGN1cmluZi0+dmNwdS0+dmNwdV9pZCk7DQogICAgICAgICBp ZiAoIFBFUklPRF9CRUdJTihjdXJpbmYpID4gbm93ICkNCiAgICAgICAgICAgICBicmVhazsNCiAg ICAgICAgIF9fZGVsX2Zyb21fcXVldWUoY3VyaW5mLT52Y3B1KTsNCiAgICAgICAgIF9fYWRkX3Rv X3J1bnF1ZXVlX3NvcnQoY3VyaW5mLT52Y3B1KTsNCiAgICAgfQ0KICANCi0gICAgUFJJTlQoMywi VXBkYXRpbmcgcnVucS4uXG4iKTsNCi0NCi0gICAgLyogUHJvY2VzcyB0aGUgcnVucSwgZmluZCBk b21haW5zIHRoYXQgYXJlIG9uIHRoZSBydW5xIHRoYXQgc2hvdWxkbid0LiAqLw0KKyAgICAvKiBQ cm9jZXNzIHRoZSBydW5xLCBmaW5kIGRvbWFpbnMgdGhhdCBhcmUgb24gdGhlIHJ1bnEgdGhhdCBz aG91bGRuJ3QgKi8NCiAgICAgbGlzdF9mb3JfZWFjaF9zYWZlICggY3VyLCB0bXAsIHJ1bnEgKQ0K ICAgICB7DQogICAgICAgICBjdXJpbmYgPSBsaXN0X2VudHJ5KGN1cixzdHJ1Y3Qgc2VkZl92Y3B1 X2luZm8sbGlzdCk7DQotICAgICAgICBQUklOVCg0LCJcdExvb2tpbmcgQCBkb20gJWkuJWlcbiIs DQotICAgICAgICAgICAgICBjdXJpbmYtPnZjcHUtPmRvbWFpbi0+ZG9tYWluX2lkLCBjdXJpbmYt PnZjcHUtPnZjcHVfaWQpOw0KIA0KICAgICAgICAgaWYgKCB1bmxpa2VseShjdXJpbmYtPnNsaWNl ID09IDApICkNCiAgICAgICAgIHsNCi0gICAgICAgICAgICAvKiBJZ25vcmUgZG9tYWlucyB3aXRo IGVtcHR5IHNsaWNlLiAqLw0KLSAgICAgICAgICAgIFBSSU5UKDQsIlx0VXBkYXRpbmcgemVyby1z bGljZSBkb21haW4gJWkuJWlcbiIsDQotICAgICAgICAgICAgICAgICAgY3VyaW5mLT52Y3B1LT5k b21haW4tPmRvbWFpbl9pZCwNCi0gICAgICAgICAgICAgICAgICBjdXJpbmYtPnZjcHUtPnZjcHVf aWQpOw0KKyAgICAgICAgICAgIC8qIElnbm9yZSBkb21haW5zIHdpdGggZW1wdHkgc2xpY2UgKi8N CiAgICAgICAgICAgICBfX2RlbF9mcm9tX3F1ZXVlKGN1cmluZi0+dmNwdSk7DQogDQotICAgICAg ICAgICAgLyogTW92ZSB0aGVtIHRvIHRoZWlyIG5leHQgcGVyaW9kLiAqLw0KKyAgICAgICAgICAg IC8qIE1vdmUgdGhlbSB0byB0aGVpciBuZXh0IHBlcmlvZCAqLw0KICAgICAgICAgICAgIGN1cmlu Zi0+ZGVhZGxfYWJzICs9IGN1cmluZi0+cGVyaW9kOw0KIA0KLSAgICAgICAgICAgIC8qIEVuc3Vy ZSB0aGF0IHRoZSBzdGFydCBvZiB0aGUgbmV4dCBwZXJpb2QgaXMgaW4gdGhlIGZ1dHVyZS4gKi8N CisgICAgICAgICAgICAvKiBFbnN1cmUgdGhhdCB0aGUgc3RhcnQgb2YgdGhlIG5leHQgcGVyaW9k IGlzIGluIHRoZSBmdXR1cmUgKi8NCiAgICAgICAgICAgICBpZiAoIHVubGlrZWx5KFBFUklPRF9C RUdJTihjdXJpbmYpIDwgbm93KSApDQogICAgICAgICAgICAgICAgIGN1cmluZi0+ZGVhZGxfYWJz ICs9IA0KICAgICAgICAgICAgICAgICAgICAgKERJVl9VUChub3cgLSBQRVJJT0RfQkVHSU4oY3Vy aW5mKSwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY3VyaW5mLT5wZXJpb2QpKSAqIGN1 cmluZi0+cGVyaW9kOw0KIA0KLSAgICAgICAgICAgIC8qIFB1dCB0aGVtIGJhY2sgaW50byB0aGUg cXVldWUuICovDQorICAgICAgICAgICAgLyogUHV0IHRoZW0gYmFjayBpbnRvIHRoZSBxdWV1ZSAq Lw0KICAgICAgICAgICAgIF9fYWRkX3RvX3dhaXRxdWV1ZV9zb3J0KGN1cmluZi0+dmNwdSk7DQog ICAgICAgICB9DQogICAgICAgICBlbHNlIGlmICggdW5saWtlbHkoKGN1cmluZi0+ZGVhZGxfYWJz IDwgbm93KSB8fA0KQEAgLTU3MSwxOCArNTE4LDE4IEBAIHN0YXRpYyB2b2lkIHVwZGF0ZV9xdWV1 ZXMoDQogICAgICAgICAgICAgICogV2UgbWlzc2VkIHRoZSBkZWFkbGluZSBvciB0aGUgc2xpY2Ug d2FzIGFscmVhZHkgZmluaXNoZWQuDQogICAgICAgICAgICAgICogTWlnaHQgaGFwZW4gYmVjYXVz ZSBvZiBkb21fYWRqLg0KICAgICAgICAgICAgICAqLw0KLSAgICAgICAgICAgIFBSSU5UKDQsIlx0 RG9tYWluICVpLiVpIGV4Y2VlZGVkIGl0J3MgZGVhZGxpbmUvIg0KLSAgICAgICAgICAgICAgICAg ICJzbGljZSAoJSJQUkl1NjQiIC8gJSJQUkl1NjQiKSBub3c6ICUiUFJJdTY0DQotICAgICAgICAg ICAgICAgICAgIiBjcHV0aW1lOiAlIlBSSXU2NCJcbiIsDQotICAgICAgICAgICAgICAgICAgY3Vy aW5mLT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwNCi0gICAgICAgICAgICAgICAgICBjdXJpbmYt PnZjcHUtPnZjcHVfaWQsDQotICAgICAgICAgICAgICAgICAgY3VyaW5mLT5kZWFkbF9hYnMsIGN1 cmluZi0+c2xpY2UsIG5vdywNCi0gICAgICAgICAgICAgICAgICBjdXJpbmYtPmNwdXRpbWUpOw0K KyAgICAgICAgICAgIHByaW50aygiXHREb21haW4gJWkuJWkgZXhjZWVkZWQgaXQncyBkZWFkbGlu ZS8iDQorICAgICAgICAgICAgICAgICAgICJzbGljZSAoJSJQUkl1NjQiIC8gJSJQUkl1NjQiKSBu b3c6ICUiUFJJdTY0DQorICAgICAgICAgICAgICAgICAgICIgY3B1dGltZTogJSJQUkl1NjQiXG4i LA0KKyAgICAgICAgICAgICAgICAgICBjdXJpbmYtPnZjcHUtPmRvbWFpbi0+ZG9tYWluX2lkLA0K KyAgICAgICAgICAgICAgICAgICBjdXJpbmYtPnZjcHUtPnZjcHVfaWQsDQorICAgICAgICAgICAg ICAgICAgIGN1cmluZi0+ZGVhZGxfYWJzLCBjdXJpbmYtPnNsaWNlLCBub3csDQorICAgICAgICAg ICAgICAgICAgIGN1cmluZi0+Y3B1dGltZSk7DQogICAgICAgICAgICAgX19kZWxfZnJvbV9xdWV1 ZShjdXJpbmYtPnZjcHUpOw0KIA0KLSAgICAgICAgICAgIC8qIENvbW1vbiBjYXNlOiB3ZSBtaXNz IG9uZSBwZXJpb2QuICovDQorICAgICAgICAgICAgLyogQ29tbW9uIGNhc2U6IHdlIG1pc3Mgb25l IHBlcmlvZCAqLw0KICAgICAgICAgICAgIGN1cmluZi0+ZGVhZGxfYWJzICs9IGN1cmluZi0+cGVy aW9kOw0KLSAgIA0KKw0KICAgICAgICAgICAgIC8qDQogICAgICAgICAgICAgICogSWYgd2UgYXJl IHN0aWxsIGJlaGluZDogbW9kdWxvIGFyaXRobWV0aWMsIGZvcmNlIGRlYWRsaW5lDQogICAgICAg ICAgICAgICogdG8gYmUgaW4gZnV0dXJlIGFuZCBhbGlnbmVkIHRvIHBlcmlvZCBib3JkZXJzLg0K QEAgLTU5Myw3ICs1NDAsNyBAQCBzdGF0aWMgdm9pZCB1cGRhdGVfcXVldWVzKA0KICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGN1cmluZi0+cGVyaW9kKSAqIGN1cmluZi0+cGVyaW9kOw0KICAg ICAgICAgICAgIEFTU0VSVChjdXJpbmYtPmRlYWRsX2FicyA+PSBub3cpOw0KIA0KLSAgICAgICAg ICAgIC8qIEdpdmUgYSBmcmVzaCBzbGljZS4gKi8NCisgICAgICAgICAgICAvKiBHaXZlIGEgZnJl c2ggc2xpY2UgKi8NCiAgICAgICAgICAgICBjdXJpbmYtPmNwdXRpbWUgPSAwOw0KICAgICAgICAg ICAgIGlmICggUEVSSU9EX0JFR0lOKGN1cmluZikgPiBub3cgKQ0KICAgICAgICAgICAgICAgICBf X2FkZF90b193YWl0cXVldWVfc29ydChjdXJpbmYtPnZjcHUpOw0KQEAgLTYwMywxNyArNTUwLDE3 IEBAIHN0YXRpYyB2b2lkIHVwZGF0ZV9xdWV1ZXMoDQogICAgICAgICBlbHNlDQogICAgICAgICAg ICAgYnJlYWs7DQogICAgIH0NCi0NCi0gICAgUFJJTlQoMywiZG9uZSB1cGRhdGluZyB0aGUgcXVl dWVzXG4iKTsNCiB9DQogDQogDQotLyogcmVtb3ZlcyBhIGRvbWFpbiBmcm9tIHRoZSBoZWFkIG9m IHRoZSBhY2NvcmRpbmcgZXh0cmFRIGFuZA0KLSAgIHJlcXVldWVzIGl0IGF0IGEgc3BlY2lmaWVk IHBvc2l0aW9uOg0KLSAgICAgcm91bmQtcm9iaW4gZXh0cmF0aW1lOiBlbmQgb2YgZXh0cmFRDQot ICAgICB3ZWlnaHRlZCBleHQuOiBpbnNlcnQgaW4gc29ydGVkIGxpc3QgYnkgc2NvcmUNCi0gICBp ZiB0aGUgZG9tYWluIGlzIGJsb2NrZWQgLyBoYXMgcmVnYWluZWQgaXRzIHNob3J0LWJsb2NrLWxv c3MNCi0gICB0aW1lIGl0IGlzIG5vdCBwdXQgb24gYW55IHF1ZXVlICovDQorLyoNCisgKiByZW1v dmVzIGEgZG9tYWluIGZyb20gdGhlIGhlYWQgb2YgdGhlIGFjY29yZGluZyBleHRyYVEgYW5kDQor ICogcmVxdWV1ZXMgaXQgYXQgYSBzcGVjaWZpZWQgcG9zaXRpb246DQorICogICByb3VuZC1yb2Jp biBleHRyYXRpbWU6IGVuZCBvZiBleHRyYVENCisgKiAgIHdlaWdodGVkIGV4dC46IGluc2VydCBp biBzb3J0ZWQgbGlzdCBieSBzY29yZQ0KKyAqIGlmIHRoZSBkb21haW4gaXMgYmxvY2tlZCAvIGhh cyByZWdhaW5lZCBpdHMgc2hvcnQtYmxvY2stbG9zcw0KKyAqIHRpbWUgaXQgaXMgbm90IHB1dCBv biBhbnkgcXVldWUuDQorICovDQogc3RhdGljIHZvaWQgZGVzY2hlZF9leHRyYV9kb20oc190aW1l X3Qgbm93LCBzdHJ1Y3QgdmNwdSAqZCkNCiB7DQogICAgIHN0cnVjdCBzZWRmX3ZjcHVfaW5mbyAq aW5mID0gRURPTV9JTkZPKGQpOw0KQEAgLTYyMiwyOSArNTY5LDI1IEBAIHN0YXRpYyB2b2lkIGRl c2NoZWRfZXh0cmFfZG9tKHNfdGltZV90IG4NCiANCiAgICAgQVNTRVJUKGV4dHJhcV9vbihkLCBp KSk7DQogDQotICAgIC8qIFVuc2V0IGFsbCBydW5uaW5nIGZsYWdzLiAqLw0KKyAgICAvKiBVbnNl dCBhbGwgcnVubmluZyBmbGFncyAqLw0KICAgICBpbmYtPnN0YXR1cyAgJj0gfihFWFRSQV9SVU5f UEVOIHwgRVhUUkFfUlVOX1VUSUwpOw0KLSAgICAvKiBGcmVzaCBzbGljZSBmb3IgdGhlIG5leHQg cnVuLiAqLw0KKyAgICAvKiBGcmVzaCBzbGljZSBmb3IgdGhlIG5leHQgcnVuICovDQogICAgIGlu Zi0+Y3B1dGltZSA9IDA7DQotICAgIC8qIEFjY3VtdWxhdGUgdG90YWwgZXh0cmF0aW1lLiAqLw0K KyAgICAvKiBBY2N1bXVsYXRlIHRvdGFsIGV4dHJhdGltZSAqLw0KICAgICBpbmYtPmV4dHJhX3Rp bWVfdG90ICs9IG5vdyAtIGluZi0+c2NoZWRfc3RhcnRfYWJzOw0KICAgICAvKiBSZW1vdmUgZXh0 cmFkb21haW4gZnJvbSBoZWFkIG9mIHRoZSBxdWV1ZS4gKi8NCiAgICAgZXh0cmFxX2RlbChkLCBp KTsNCiANCi0gICAgLyogVXBkYXRlIHRoZSBzY29yZS4gKi8NCisgICAgLyogVXBkYXRlIHRoZSBz Y29yZSAqLw0KICAgICBvbGRzY29yZSA9IGluZi0+c2NvcmVbaV07DQogICAgIGlmICggaSA9PSBF WFRSQV9QRU5fUSApDQogICAgIHsNCi0gICAgICAgIC8qZG9tYWluIHdhcyBydW5uaW5nIGluIEww IGV4dHJhcSovDQotICAgICAgICAvKnJlZHVjZSBibG9jayBsb3N0LCBwcm9iYWJseSBtb3JlIHNv cGhpc3RpY2F0aW9uIGhlcmUhKi8NCisgICAgICAgIC8qIERvbWFpbiB3YXMgcnVubmluZyBpbiBM MCBleHRyYXEgKi8NCisgICAgICAgIC8qIHJlZHVjZSBibG9jayBsb3N0LCBwcm9iYWJseSBtb3Jl IHNvcGhpc3RpY2F0aW9uIGhlcmUhKi8NCiAgICAgICAgIC8qaW5mLT5zaG9ydF9ibG9ja19sb3N0 X3RvdCAtPSBFWFRSQV9RVUFOVFVNOyovDQogICAgICAgICBpbmYtPnNob3J0X2Jsb2NrX2xvc3Rf dG90IC09IG5vdyAtIGluZi0+c2NoZWRfc3RhcnRfYWJzOw0KLSAgICAgICAgUFJJTlQoMywiRG9t YWluICVpLiVpOiBTaG9ydF9ibG9ja19sb3NzOiAlIlBSSWk2NCJcbiIsIA0KLSAgICAgICAgICAg ICAgaW5mLT52Y3B1LT5kb21haW4tPmRvbWFpbl9pZCwgaW5mLT52Y3B1LT52Y3B1X2lkLA0KLSAg ICAgICAgICAgICAgaW5mLT5zaG9ydF9ibG9ja19sb3N0X3RvdCk7DQogI2lmIDANCi0gICAgICAg IC8qDQotICAgICAgICAgKiBLQUY6IElmIHdlIGRvbid0IGV4aXQgc2hvcnQtYmxvY2tpbmcgc3Rh dGUgYXQgdGhpcyBwb2ludA0KKyAgICAgICAgLyogS0FGOiBJZiB3ZSBkb24ndCBleGl0IHNob3J0 LWJsb2NraW5nIHN0YXRlIGF0IHRoaXMgcG9pbnQNCiAgICAgICAgICAqIGRvbWFpbjAgY2FuIHN0 ZWFsIGFsbCBDUFUgZm9yIHVwIHRvIDEwIHNlY29uZHMgYmVmb3JlDQogICAgICAgICAgKiBzY2hl ZHVsaW5nIHNldHRsZXMgZG93biAod2hlbiBjb21wZXRpbmcgYWdhaW5zdCBhbm90aGVyDQogICAg ICAgICAgKiBDUFUtYm91bmQgZG9tYWluKS4gRG9pbmcgdGhpcyBzZWVtcyB0byBtYWtlIHRoaW5n cyBiZWhhdmUNCkBAIC02NTMsNTEgKzU5Niw1OSBAQCBzdGF0aWMgdm9pZCBkZXNjaGVkX2V4dHJh X2RvbShzX3RpbWVfdCBuDQogICAgICAgICBpZiAoIGluZi0+c2hvcnRfYmxvY2tfbG9zdF90b3Qg PD0gMCApDQogI2VuZGlmDQogICAgICAgICB7DQotICAgICAgICAgICAgUFJJTlQoNCwiRG9tYWlu ICVpLiVpIGNvbXBlbnNhdGVkIHNob3J0IGJsb2NrIGxvc3MhXG4iLA0KLSAgICAgICAgICAgICAg ICAgIGluZi0+dmNwdS0+ZG9tYWluLT5kb21haW5faWQsIGluZi0+dmNwdS0+dmNwdV9pZCk7DQot ICAgICAgICAgICAgLyp3ZSBoYXZlIChvdmVyLSljb21wZW5zYXRlZCBvdXIgYmxvY2sgcGVuYWx0 eSovDQorICAgICAgICAgICAgLyogV2UgaGF2ZSAob3Zlci0pY29tcGVuc2F0ZWQgb3VyIGJsb2Nr IHBlbmFsdHkgKi8NCiAgICAgICAgICAgICBpbmYtPnNob3J0X2Jsb2NrX2xvc3RfdG90ID0gMDsN Ci0gICAgICAgICAgICAvKndlIGRvbid0IHdhbnQgYSBwbGFjZSBvbiB0aGUgcGVuYWx0eSBxdWV1 ZSBhbnltb3JlISovDQorICAgICAgICAgICAgLyogV2UgZG9uJ3Qgd2FudCBhIHBsYWNlIG9uIHRo ZSBwZW5hbHR5IHF1ZXVlIGFueW1vcmUhICovDQogICAgICAgICAgICAgaW5mLT5zdGF0dXMgJj0g fkVYVFJBX1dBTlRfUEVOX1E7DQogICAgICAgICAgICAgZ290byBjaGVja19leHRyYV9xdWV1ZXM7 DQogICAgICAgICB9DQogDQotICAgICAgICAvKndlIGhhdmUgdG8gZ28gYWdhaW4gZm9yIGFub3Ro ZXIgdHJ5IGluIHRoZSBibG9jay1leHRyYXEsDQotICAgICAgICAgIHRoZSBzY29yZSBpcyBub3Qg dXNlZCBpbmNyZW1hbnRhbGx5IGhlcmUsIGFzIHRoaXMgaXMNCi0gICAgICAgICAgYWxyZWFkeSBk b25lIGJ5IHJlY2FsY3VsYXRpbmcgdGhlIGJsb2NrX2xvc3QqLw0KKyAgICAgICAgLyoNCisgICAg ICAgICAqIFdlIGhhdmUgdG8gZ28gYWdhaW4gZm9yIGFub3RoZXIgdHJ5IGluIHRoZSBibG9jay1l eHRyYXEsDQorICAgICAgICAgKiB0aGUgc2NvcmUgaXMgbm90IHVzZWQgaW5jcmVtYW50YWxseSBo ZXJlLCBhcyB0aGlzIGlzDQorICAgICAgICAgKiBhbHJlYWR5IGRvbmUgYnkgcmVjYWxjdWxhdGlu ZyB0aGUgYmxvY2tfbG9zdA0KKyAgICAgICAgICovDQogICAgICAgICBpbmYtPnNjb3JlW0VYVFJB X1BFTl9RXSA9IChpbmYtPnBlcmlvZCA8PCAxMCkgLw0KICAgICAgICAgICAgIGluZi0+c2hvcnRf YmxvY2tfbG9zdF90b3Q7DQogICAgICAgICBvbGRzY29yZSA9IDA7DQogICAgIH0NCiAgICAgZWxz ZQ0KICAgICB7DQotICAgICAgICAvKmRvbWFpbiB3YXMgcnVubmluZyBpbiBMMSBleHRyYXEgPT4g c2NvcmUgaXMgaW52ZXJzZSBvZg0KLSAgICAgICAgICB1dGlsaXphdGlvbiBhbmQgaXMgdXNlZCBz b21ld2hhdCBpbmNyZW1lbnRhbCEqLw0KKyAgICAgICAgLyoNCisgICAgICAgICAqIERvbWFpbiB3 YXMgcnVubmluZyBpbiBMMSBleHRyYXEgPT4gc2NvcmUgaXMgaW52ZXJzZSBvZg0KKyAgICAgICAg ICogdXRpbGl6YXRpb24gYW5kIGlzIHVzZWQgc29tZXdoYXQgaW5jcmVtZW50YWwhDQorICAgICAg ICAgKi8NCiAgICAgICAgIGlmICggIWluZi0+ZXh0cmF3ZWlnaHQgKQ0KLSAgICAgICAgICAgIC8q TkI6IHVzZSBmaXhlZCBwb2ludCBhcml0aG1ldGljIHdpdGggMTAgYml0cyovDQorICAgICAgICB7 DQorICAgICAgICAgICAgLyogTkI6IHVzZSBmaXhlZCBwb2ludCBhcml0aG1ldGljIHdpdGggMTAg Yml0cyAqLw0KICAgICAgICAgICAgIGluZi0+c2NvcmVbRVhUUkFfVVRJTF9RXSA9IChpbmYtPnBl cmlvZCA8PCAxMCkgLw0KICAgICAgICAgICAgICAgICBpbmYtPnNsaWNlOw0KKyAgICAgICAgfQ0K ICAgICAgICAgZWxzZQ0KLSAgICAgICAgICAgIC8qY29udmVyc2lvbiBiZXR3ZWVuIHJlYWx0aW1l IHV0aWxpc2F0aW9uIGFuZCBleHRyYXdpZWdodDoNCi0gICAgICAgICAgICAgIGZ1bGwgKGllIDEw MCUpIHV0aWxpemF0aW9uIGlzIGVxdWl2YWxlbnQgdG8gMTI4IGV4dHJhd2VpZ2h0Ki8NCisgICAg ICAgIHsNCisgICAgICAgICAgICAvKg0KKyAgICAgICAgICAgICAqIENvbnZlcnNpb24gYmV0d2Vl biByZWFsdGltZSB1dGlsaXNhdGlvbiBhbmQgZXh0cmF3aWVnaHQ6DQorICAgICAgICAgICAgICog ZnVsbCAoaWUgMTAwJSkgdXRpbGl6YXRpb24gaXMgZXF1aXZhbGVudCB0byAxMjggZXh0cmF3ZWln aHQNCisgICAgICAgICAgICAgKi8NCiAgICAgICAgICAgICBpbmYtPnNjb3JlW0VYVFJBX1VUSUxf UV0gPSAoMTw8MTcpIC8gaW5mLT5leHRyYXdlaWdodDsNCisgICAgICAgIH0NCiAgICAgfQ0KIA0K ICBjaGVja19leHRyYV9xdWV1ZXM6DQotICAgIC8qIEFkZGluZyBhIHJ1bm5hYmxlIGRvbWFpbiB0 byB0aGUgcmlnaHQgcXVldWUgYW5kIHJlbW92aW5nIGJsb2NrZWQgb25lcyovDQorICAgIC8qIEFk ZGluZyBhIHJ1bm5hYmxlIGRvbWFpbiB0byB0aGUgcmlnaHQgcXVldWUgYW5kIHJlbW92aW5nIGJs b2NrZWQgb25lcyAqLw0KICAgICBpZiAoIHNlZGZfcnVubmFibGUoZCkgKQ0KICAgICB7DQotICAg ICAgICAvKmFkZCBhY2NvcmRpbmcgdG8gc2NvcmU6IHdlaWdodGVkIHJvdW5kIHJvYmluKi8NCisg ICAgICAgIC8qIEFkZCBhY2NvcmRpbmcgdG8gc2NvcmU6IHdlaWdodGVkIHJvdW5kIHJvYmluICov DQogICAgICAgICBpZiAoKChpbmYtPnN0YXR1cyAmIEVYVFJBX0FXQVJFKSAmJiAoaSA9PSBFWFRS QV9VVElMX1EpKSB8fA0KICAgICAgICAgICAgICgoaW5mLT5zdGF0dXMgJiBFWFRSQV9XQU5UX1BF Tl9RKSAmJiAoaSA9PSBFWFRSQV9QRU5fUSkpKQ0KICAgICAgICAgICAgIGV4dHJhcV9hZGRfc29y dF91cGRhdGUoZCwgaSwgb2xkc2NvcmUpOw0KICAgICB9DQogICAgIGVsc2UNCiAgICAgew0KLSAg ICAgICAgLypyZW1vdmUgdGhpcyBibG9ja2VkIGRvbWFpbiBmcm9tIHRoZSB3YWl0cSEqLw0KKyAg ICAgICAgLyogUmVtb3ZlIHRoaXMgYmxvY2tlZCBkb21haW4gZnJvbSB0aGUgd2FpdHEhICovDQog ICAgICAgICBfX2RlbF9mcm9tX3F1ZXVlKGQpOw0KLSAgICAgICAgLyptYWtlIHN1cmUgdGhhdCB3 ZSByZW1vdmUgYSBibG9ja2VkIGRvbWFpbiBmcm9tIHRoZSBvdGhlcg0KLSAgICAgICAgICBleHRy YXEgdG9vKi8NCisgICAgICAgIC8qIE1ha2Ugc3VyZSB0aGF0IHdlIHJlbW92ZSBhIGJsb2NrZWQg ZG9tYWluIGZyb20gdGhlIG90aGVyDQorICAgICAgICAgKiBleHRyYXEgdG9vLiAqLw0KICAgICAg ICAgaWYgKCBpID09IEVYVFJBX1BFTl9RICkNCiAgICAgICAgIHsNCiAgICAgICAgICAgICBpZiAo IGV4dHJhcV9vbihkLCBFWFRSQV9VVElMX1EpICkNCkBAIC03MjksOCArNjgwLDEwIEBAIHN0YXRp YyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX2V4dHJhX3MNCiANCiAgICAgaWYgKCAhbGlzdF9l bXB0eShleHRyYXFbRVhUUkFfUEVOX1FdKSApDQogICAgIHsNCi0gICAgICAgIC8qd2Ugc3RpbGwg aGF2ZSBlbGVtZW50cyBvbiB0aGUgbGV2ZWwgMCBleHRyYXEgDQotICAgICAgICAgID0+IGxldCB0 aG9zZSBydW4gZmlyc3QhKi8NCisgICAgICAgIC8qDQorICAgICAgICAgKiBXZSBzdGlsbCBoYXZl IGVsZW1lbnRzIG9uIHRoZSBsZXZlbCAwIGV4dHJhcQ0KKyAgICAgICAgICogPT4gbGV0IHRob3Nl IHJ1biBmaXJzdCENCisgICAgICAgICAqLw0KICAgICAgICAgcnVuaW5mICAgPSBsaXN0X2VudHJ5 KGV4dHJhcVtFWFRSQV9QRU5fUV0tPm5leHQsIA0KICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHN0cnVjdCBzZWRmX3ZjcHVfaW5mbywgZXh0cmFsaXN0W0VYVFJBX1BFTl9RXSk7DQogICAg ICAgICBydW5pbmYtPnN0YXR1cyB8PSBFWFRSQV9SVU5fUEVOOw0KQEAgLTc0NCw3ICs2OTcsNyBA QCBzdGF0aWMgc3RydWN0IHRhc2tfc2xpY2Ugc2VkZl9kb19leHRyYV9zDQogICAgIHsNCiAgICAg ICAgIGlmICggIWxpc3RfZW1wdHkoZXh0cmFxW0VYVFJBX1VUSUxfUV0pICkNCiAgICAgICAgIHsN Ci0gICAgICAgICAgICAvKnVzZSBlbGVtZW50cyBmcm9tIHRoZSBub3JtYWwgZXh0cmFxdWV1ZSov DQorICAgICAgICAgICAgLyogVXNlIGVsZW1lbnRzIGZyb20gdGhlIG5vcm1hbCBleHRyYXF1ZXVl ICovDQogICAgICAgICAgICAgcnVuaW5mICAgPSBsaXN0X2VudHJ5KGV4dHJhcVtFWFRSQV9VVElM X1FdLT5uZXh0LA0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qgc2Vk Zl92Y3B1X2luZm8sDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGV4dHJhbGlz dFtFWFRSQV9VVElMX1FdKTsNCkBAIC03OTQsMTEgKzc0NywxMyBAQCBzdGF0aWMgdm9pZCBzZWRm X2RlaW5pdChjb25zdCBzdHJ1Y3Qgc2NoDQogfQ0KIA0KIA0KLS8qIE1haW4gc2NoZWR1bGluZyBm dW5jdGlvbg0KLSAgIFJlYXNvbnMgZm9yIGNhbGxpbmcgdGhpcyBmdW5jdGlvbiBhcmU6DQotICAg LXRpbWVzbGljZSBmb3IgdGhlIGN1cnJlbnQgcGVyaW9kIHVzZWQgdXANCi0gICAtZG9tYWluIG9u IHdhaXRxdWV1ZSBoYXMgc3RhcnRlZCBpdCdzIHBlcmlvZA0KLSAgIC1hbmQgdmFyaW91cyBvdGhl cnMgOykgaW4gZ2VuZXJhbDogZGV0ZXJtaW5lIHdoaWNoIGRvbWFpbiB0byBydW4gbmV4dCovDQor LyoNCisgKiBNYWluIHNjaGVkdWxpbmcgZnVuY3Rpb24NCisgKiBSZWFzb25zIGZvciBjYWxsaW5n IHRoaXMgZnVuY3Rpb24gYXJlOg0KKyAqIC10aW1lc2xpY2UgZm9yIHRoZSBjdXJyZW50IHBlcmlv ZCB1c2VkIHVwDQorICogLWRvbWFpbiBvbiB3YWl0cXVldWUgaGFzIHN0YXJ0ZWQgaXQncyBwZXJp b2QNCisgKiAtYW5kIHZhcmlvdXMgb3RoZXJzIDspIGluIGdlbmVyYWw6IGRldGVybWluZSB3aGlj aCBkb21haW4gdG8gcnVuIG5leHQNCisgKi8NCiBzdGF0aWMgc3RydWN0IHRhc2tfc2xpY2Ugc2Vk Zl9kb19zY2hlZHVsZSgNCiAgICAgY29uc3Qgc3RydWN0IHNjaGVkdWxlciAqb3BzLCBzX3RpbWVf dCBub3csIGJvb2xfdCB0YXNrbGV0X3dvcmtfc2NoZWR1bGVkKQ0KIHsNCkBAIC04MTEsMTMgKzc2 NiwxNSBAQCBzdGF0aWMgc3RydWN0IHRhc2tfc2xpY2Ugc2VkZl9kb19zY2hlZHVsDQogICAgIHN0 cnVjdCBzZWRmX3ZjcHVfaW5mbyAqcnVuaW5mLCAqd2FpdGluZjsNCiAgICAgc3RydWN0IHRhc2tf c2xpY2UgICAgICByZXQ7DQogDQotICAgIC8qaWRsZSB0YXNrcyBkb24ndCBuZWVkIGFueSBvZiB0 aGUgZm9sbG93aW5nIHN0dWYqLw0KKyAgICAvKiBJZGxlIHRhc2tzIGRvbid0IG5lZWQgYW55IG9m IHRoZSBmb2xsb3dpbmcgc3R1ZiAqLw0KICAgICBpZiAoIGlzX2lkbGVfdmNwdShjdXJyZW50KSAp DQogICAgICAgICBnb3RvIGNoZWNrX3dhaXRxOw0KLSANCi0gICAgLyogY3JlYXRlIGxvY2FsIHN0 YXRlIG9mIHRoZSBzdGF0dXMgb2YgdGhlIGRvbWFpbiwgaW4gb3JkZXIgdG8gYXZvaWQNCi0gICAg ICAgaW5jb25zaXN0ZW50IHN0YXRlIGR1cmluZyBzY2hlZHVsaW5nIGRlY2lzaW9ucywgYmVjYXVz ZSBkYXRhIGZvcg0KLSAgICAgICB2Y3B1X3J1bm5hYmxlIGlzIG5vdCBwcm90ZWN0ZWQgYnkgdGhl IHNjaGVkdWxpbmcgbG9jayEqLw0KKw0KKyAgICAvKg0KKyAgICAgKiBDcmVhdGUgbG9jYWwgc3Rh dGUgb2YgdGhlIHN0YXR1cyBvZiB0aGUgZG9tYWluLCBpbiBvcmRlciB0byBhdm9pZA0KKyAgICAg KiBpbmNvbnNpc3RlbnQgc3RhdGUgZHVyaW5nIHNjaGVkdWxpbmcgZGVjaXNpb25zLCBiZWNhdXNl IGRhdGEgZm9yDQorICAgICAqIHZjcHVfcnVubmFibGUgaXMgbm90IHByb3RlY3RlZCBieSB0aGUg c2NoZWR1bGluZyBsb2NrIQ0KKyAgICAgKi8NCiAgICAgaWYgKCAhdmNwdV9ydW5uYWJsZShjdXJy ZW50KSApDQogICAgICAgICBpbmYtPnN0YXR1cyB8PSBTRURGX0FTTEVFUDsNCiAgDQpAQCAtODI2 LDcgKzc4Myw3IEBAIHN0YXRpYyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX3NjaGVkdWwNCiAN CiAgICAgaWYgKCB1bmxpa2VseShleHRyYV9ydW5zKGluZikpICkNCiAgICAgew0KLSAgICAgICAg LypzcGVjaWFsIHRyZWF0bWVudCBvZiBkb21haW5zIHJ1bm5pbmcgaW4gZXh0cmEgdGltZSovDQor ICAgICAgICAvKiBTcGVjaWFsIHRyZWF0bWVudCBvZiBkb21haW5zIHJ1bm5pbmcgaW4gZXh0cmEg dGltZSAqLw0KICAgICAgICAgZGVzY2hlZF9leHRyYV9kb20obm93LCBjdXJyZW50KTsNCiAgICAg fQ0KICAgICBlbHNlIA0KQEAgLTgzNiwxMCArNzkzLDEyIEBAIHN0YXRpYyBzdHJ1Y3QgdGFza19z bGljZSBzZWRmX2RvX3NjaGVkdWwNCiAgY2hlY2tfd2FpdHE6DQogICAgIHVwZGF0ZV9xdWV1ZXMo bm93LCBydW5xLCB3YWl0cSk7DQogDQotICAgIC8qbm93IHNpbXBseSBwaWNrIHRoZSBmaXJzdCBk b21haW4gZnJvbSB0aGUgcnVucXVldWUsIHdoaWNoIGhhcyB0aGUNCi0gICAgICBlYXJsaWVzdCBk ZWFkbGluZSwgYmVjYXVzZSB0aGUgbGlzdCBpcyBzb3J0ZWQqLw0KLSANCi0gICAgLyogVGFza2xl dCB3b3JrICh3aGljaCBydW5zIGluIGlkbGUgVkNQVSBjb250ZXh0KSBvdmVycmlkZXMgYWxsIGVs c2UuICovDQorICAgIC8qDQorICAgICAqIE5vdyBzaW1wbHkgcGljayB0aGUgZmlyc3QgZG9tYWlu IGZyb20gdGhlIHJ1bnF1ZXVlLCB3aGljaCBoYXMgdGhlDQorICAgICAqIGVhcmxpZXN0IGRlYWRs aW5lLCBiZWNhdXNlIHRoZSBsaXN0IGlzIHNvcnRlZA0KKyAgICAgKg0KKyAgICAgKiBUYXNrbGV0 IHdvcmsgKHdoaWNoIHJ1bnMgaW4gaWRsZSBWQ1BVIGNvbnRleHQpIG92ZXJyaWRlcyBhbGwgZWxz ZS4NCisgICAgICovDQogICAgIGlmICggdGFza2xldF93b3JrX3NjaGVkdWxlZCB8fA0KICAgICAg ICAgIChsaXN0X2VtcHR5KHJ1bnEpICYmIGxpc3RfZW1wdHkod2FpdHEpKSB8fA0KICAgICAgICAg IHVubGlrZWx5KCFjcHVtYXNrX3Rlc3RfY3B1KGNwdSwgU0VERl9DUFVPTkxJTkUocGVyX2NwdShj cHVwb29sLCBjcHUpKSkpICkNCkBAIC04NTUsOSArODE0LDExIEBAIHN0YXRpYyBzdHJ1Y3QgdGFz a19zbGljZSBzZWRmX2RvX3NjaGVkdWwNCiAgICAgICAgIHsNCiAgICAgICAgICAgICB3YWl0aW5m ICA9IGxpc3RfZW50cnkod2FpdHEtPm5leHQsDQogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHN0cnVjdCBzZWRmX3ZjcHVfaW5mbyxsaXN0KTsNCi0gICAgICAgICAgICAvKnJlcnVu IHNjaGVkdWxlciwgd2hlbiBzY2hlZHVsZWQgZG9tYWluIHJlYWNoZXMgaXQncw0KLSAgICAgICAg ICAgICAgZW5kIG9mIHNsaWNlIG9yIHRoZSBmaXJzdCBkb21haW4gZnJvbSB0aGUgd2FpdHF1ZXVl DQotICAgICAgICAgICAgICBnZXRzIHJlYWR5Ki8NCisgICAgICAgICAgICAvKg0KKyAgICAgICAg ICAgICAqIFJlcnVuIHNjaGVkdWxlciwgd2hlbiBzY2hlZHVsZWQgZG9tYWluIHJlYWNoZXMgaXQn cw0KKyAgICAgICAgICAgICAqIGVuZCBvZiBzbGljZSBvciB0aGUgZmlyc3QgZG9tYWluIGZyb20g dGhlIHdhaXRxdWV1ZQ0KKyAgICAgICAgICAgICAqIGdldHMgcmVhZHkuDQorICAgICAgICAgICAg ICovDQogICAgICAgICAgICAgcmV0LnRpbWUgPSBNSU4obm93ICsgcnVuaW5mLT5zbGljZSAtIHJ1 bmluZi0+Y3B1dGltZSwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBQRVJJT0RfQkVHSU4o d2FpdGluZikpIC0gbm93Ow0KICAgICAgICAgfQ0KQEAgLTg2OSwxNCArODMwLDE4IEBAIHN0YXRp YyBzdHJ1Y3QgdGFza19zbGljZSBzZWRmX2RvX3NjaGVkdWwNCiAgICAgZWxzZQ0KICAgICB7DQog ICAgICAgICB3YWl0aW5mICA9IGxpc3RfZW50cnkod2FpdHEtPm5leHQsc3RydWN0IHNlZGZfdmNw dV9pbmZvLCBsaXN0KTsNCi0gICAgICAgIC8qd2UgY291bGQgbm90IGZpbmQgYW55IHN1aXRhYmxl IGRvbWFpbiANCi0gICAgICAgICAgPT4gbG9vayBmb3IgZG9tYWlucyB0aGF0IGFyZSBhd2FyZSBv ZiBleHRyYXRpbWUqLw0KKyAgICAgICAgLyoNCisgICAgICAgICAqIFdlIGNvdWxkIG5vdCBmaW5k IGFueSBzdWl0YWJsZSBkb21haW4gDQorICAgICAgICAgKiA9PiBsb29rIGZvciBkb21haW5zIHRo YXQgYXJlIGF3YXJlIG9mIGV4dHJhdGltZQ0KKyAgICAgICAgICovDQogICAgICAgICByZXQgPSBz ZWRmX2RvX2V4dHJhX3NjaGVkdWxlKG5vdywgUEVSSU9EX0JFR0lOKHdhaXRpbmYpLA0KICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleHRyYXEsIGNwdSk7DQogICAgIH0NCiAN Ci0gICAgLypUT0RPOiBEbyBzb21ldGhpbmcgVVNFRlVMIHdoZW4gdGhpcyBoYXBwZW5zIGFuZCBm aW5kIG91dCwgd2h5IGl0DQotICAgICAgc3RpbGwgY2FuIGhhcHBlbiEhISovDQorICAgIC8qDQor ICAgICAqIFRPRE86IERvIHNvbWV0aGluZyBVU0VGVUwgd2hlbiB0aGlzIGhhcHBlbnMgYW5kIGZp bmQgb3V0LCB3aHkgaXQNCisgICAgICogc3RpbGwgY2FuIGhhcHBlbiEhIQ0KKyAgICAgKi8NCiAg ICAgaWYgKCByZXQudGltZSA8IDApDQogICAgIHsNCiAgICAgICAgIHByaW50aygiT3VjaCEgV2Ug YXJlIHNlcmlvdXNseSBCRUhJTkQgc2NoZWR1bGUhICUiUFJJaTY0IlxuIiwNCkBAIC04OTYsOSAr ODYxLDYgQEAgc3RhdGljIHN0cnVjdCB0YXNrX3NsaWNlIHNlZGZfZG9fc2NoZWR1bA0KIA0KIHN0 YXRpYyB2b2lkIHNlZGZfc2xlZXAoY29uc3Qgc3RydWN0IHNjaGVkdWxlciAqb3BzLCBzdHJ1Y3Qg dmNwdSAqZCkNCiB7DQotICAgIFBSSU5UKDIsInNlZGZfc2xlZXAgd2FzIGNhbGxlZCwgZG9tYWlu LWlkICVpLiVpXG4iLA0KLSAgICAgICAgICBkLT5kb21haW4tPmRvbWFpbl9pZCwgZC0+dmNwdV9p ZCk7DQotIA0KICAgICBpZiAoIGlzX2lkbGVfdmNwdShkKSApDQogICAgICAgICByZXR1cm47DQog DQpAQCAtOTIwLDcgKzg4Miw4IEBAIHN0YXRpYyB2b2lkIHNlZGZfc2xlZXAoY29uc3Qgc3RydWN0 IHNjaGUNCiB9DQogDQogDQotLyogVGhpcyBmdW5jdGlvbiB3YWtlcyB1cCBhIGRvbWFpbiwgaS5l LiBtb3ZlcyB0aGVtIGludG8gdGhlIHdhaXRxdWV1ZQ0KKy8qDQorICogVGhpcyBmdW5jdGlvbiB3 YWtlcyB1cCBhIGRvbWFpbiwgaS5lLiBtb3ZlcyB0aGVtIGludG8gdGhlIHdhaXRxdWV1ZQ0KICAq IHRoaW5ncyB0byBtZW50aW9uIGFyZTogYWRtaXNzaW9uIGNvbnRyb2wgaXMgdGFraW5nIHBsYWNl IG5vd2hlcmUgYXQNCiAgKiB0aGUgbW9tZW50LCBzbyB3ZSBjYW4ndCBiZSBzdXJlLCB3aGV0aGVy IGl0IGlzIHNhZmUgdG8gd2FrZSB0aGUgZG9tYWluDQogICogdXAgYXQgYWxsLiBBbnl3YXksIGV2 ZW4gaWYgaXQgaXMgc2FmZSAodG90YWwgY3B1IHVzYWdlIDw9MTAwJSkgdGhlcmUgYXJlDQpAQCAt OTk0LDI3ICs5NTcsMzEgQEAgc3RhdGljIHZvaWQgc2VkZl9zbGVlcChjb25zdCBzdHJ1Y3Qgc2No ZQ0KIHN0YXRpYyB2b2lkIHVuYmxvY2tfc2hvcnRfZXh0cmFfc3VwcG9ydCgNCiAgICAgc3RydWN0 IHNlZGZfdmNwdV9pbmZvKiBpbmYsIHNfdGltZV90IG5vdykNCiB7DQotICAgIC8qdGhpcyB1bmJs b2NraW5nIHNjaGVtZSB0cmllcyB0byBzdXBwb3J0IHRoZSBkb21haW4sIGJ5IGFzc2lnbmluZyBp dA0KLSAgICBhIHByaW9yaXR5IGluIGV4dHJhdGltZSBkaXN0cmlidXRpb24gYWNjb3JkaW5nIHRv IHRoZSBsb3NzIG9mIHRpbWUNCi0gICAgaW4gdGhpcyBzbGljZSBkdWUgdG8gYmxvY2tpbmcqLw0K KyAgICAvKg0KKyAgICAgKiBUaGlzIHVuYmxvY2tpbmcgc2NoZW1lIHRyaWVzIHRvIHN1cHBvcnQg dGhlIGRvbWFpbiwgYnkgYXNzaWduaW5nIGl0DQorICAgICAqIGEgcHJpb3JpdHkgaW4gZXh0cmF0 aW1lIGRpc3RyaWJ1dGlvbiBhY2NvcmRpbmcgdG8gdGhlIGxvc3Mgb2YgdGltZQ0KKyAgICAgKiBp biB0aGlzIHNsaWNlIGR1ZSB0byBibG9ja2luZw0KKyAgICAgKi8NCiAgICAgc190aW1lX3QgcGVu Ow0KICANCi0gICAgLypubyBtb3JlIHJlYWx0aW1lIGV4ZWN1dGlvbiBpbiB0aGlzIHBlcmlvZCEq Lw0KKyAgICAvKiBObyBtb3JlIHJlYWx0aW1lIGV4ZWN1dGlvbiBpbiB0aGlzIHBlcmlvZCEgKi8N CiAgICAgaW5mLT5kZWFkbF9hYnMgKz0gaW5mLT5wZXJpb2Q7DQogICAgIGlmICggbGlrZWx5KGlu Zi0+YmxvY2tfYWJzKSApDQogICAgIHsNCi0gICAgICAgIC8vdHJlYXQgYmxvY2tlZCB0aW1lIGFz IGNvbnN1bWVkIGJ5IHRoZSBkb21haW4qLw0KKyAgICAgICAgLyogVHJlYXQgYmxvY2tlZCB0aW1l IGFzIGNvbnN1bWVkIGJ5IHRoZSBkb21haW4gKi8NCiAgICAgICAgIC8qaW5mLT5jcHV0aW1lICs9 IG5vdyAtIGluZi0+YmxvY2tfYWJzOyovDQotICAgICAgICAvKnBlbmFsdHkgaXMgdGltZSB0aGUg ZG9tYWluIHdvdWxkIGhhdmUNCi0gICAgICAgICAgaGFkIGlmIGl0IGNvbnRpbnVlZCB0byBydW4g Ki8NCisgICAgICAgIC8qDQorICAgICAgICAgKiBQZW5hbHR5IGlzIHRpbWUgdGhlIGRvbWFpbiB3 b3VsZCBoYXZlDQorICAgICAgICAgKiBoYWQgaWYgaXQgY29udGludWVkIHRvIHJ1bi4NCisgICAg ICAgICAqLw0KICAgICAgICAgcGVuID0gKGluZi0+c2xpY2UgLSBpbmYtPmNwdXRpbWUpOw0KICAg ICAgICAgaWYgKCBwZW4gPCAwICkNCiAgICAgICAgICAgICBwZW4gPSAwOw0KLSAgICAgICAgLyph Y2N1bXVsYXRlIGFsbCBwZW5hbHRpZXMgb3ZlciB0aGUgcGVyaW9kcyovDQorICAgICAgICAvKiBB Y2N1bXVsYXRlIGFsbCBwZW5hbHRpZXMgb3ZlciB0aGUgcGVyaW9kcyAqLw0KICAgICAgICAgLypp bmYtPnNob3J0X2Jsb2NrX2xvc3RfdG90ICs9IHBlbjsqLw0KLSAgICAgICAgLypzZXQgcGVuYWx0 eSB0byB0aGUgY3VycmVudCB2YWx1ZSovDQorICAgICAgICAvKiBTZXQgcGVuYWx0eSB0byB0aGUg Y3VycmVudCB2YWx1ZSAqLw0KICAgICAgICAgaW5mLT5zaG9ydF9ibG9ja19sb3N0X3RvdCA9IHBl bjsNCi0gICAgICAgIC8qbm90IHN1cmUgd2hpY2ggb25lIGlzIGJldHRlci4uIGJ1dCBzZWVtcyB0 byB3b3JrIHdlbGwuLi4qLw0KKyAgICAgICAgLyogTm90IHN1cmUgd2hpY2ggb25lIGlzIGJldHRl ci4uIGJ1dCBzZWVtcyB0byB3b3JrIHdlbGwuLi4gKi8NCiAgIA0KICAgICAgICAgaWYgKCBpbmYt PnNob3J0X2Jsb2NrX2xvc3RfdG90ICkNCiAgICAgICAgIHsNCkBAIC0xMDI0LDI4ICs5OTEsMzEg QEAgc3RhdGljIHZvaWQgdW5ibG9ja19zaG9ydF9leHRyYV9zdXBwb3J0KA0KICAgICAgICAgICAg IGluZi0+cGVuX2V4dHJhX2Jsb2NrcysrOw0KICNlbmRpZg0KICAgICAgICAgICAgIGlmICggZXh0 cmFxX29uKGluZi0+dmNwdSwgRVhUUkFfUEVOX1EpICkNCi0gICAgICAgICAgICAgICAgLypyZW1v dmUgZG9tYWluIGZvciBwb3NzaWJsZSByZXNvcnRpbmchKi8NCisgICAgICAgICAgICAgICAgLyog UmVtb3ZlIGRvbWFpbiBmb3IgcG9zc2libGUgcmVzb3J0aW5nISAqLw0KICAgICAgICAgICAgICAg ICBleHRyYXFfZGVsKGluZi0+dmNwdSwgRVhUUkFfUEVOX1EpOw0KICAgICAgICAgICAgIGVsc2UN Ci0gICAgICAgICAgICAgICAgLypyZW1lbWJlciB0aGF0IHdlIHdhbnQgdG8gYmUgb24gdGhlIHBl bmFsdHkgcQ0KLSAgICAgICAgICAgICAgICAgIHNvIHRoYXQgd2UgY2FuIGNvbnRpbnVlIHdoZW4g d2UgKHVuLSlibG9jaw0KLSAgICAgICAgICAgICAgICAgIGluIHBlbmFsdHktZXh0cmF0aW1lKi8N CisgICAgICAgICAgICAgICAgLyoNCisgICAgICAgICAgICAgICAgICogUmVtZW1iZXIgdGhhdCB3 ZSB3YW50IHRvIGJlIG9uIHRoZSBwZW5hbHR5IHENCisgICAgICAgICAgICAgICAgICogc28gdGhh dCB3ZSBjYW4gY29udGludWUgd2hlbiB3ZSAodW4tKWJsb2NrDQorICAgICAgICAgICAgICAgICAq IGluIHBlbmFsdHktZXh0cmF0aW1lDQorICAgICAgICAgICAgICAgICAqLw0KICAgICAgICAgICAg ICAgICBpbmYtPnN0YXR1cyB8PSBFWFRSQV9XQU5UX1BFTl9ROw0KICAgIA0KLSAgICAgICAgICAg IC8qKHJlLSlhZGQgZG9tYWluIHRvIHRoZSBwZW5hbHR5IGV4dHJhcSovDQorICAgICAgICAgICAg LyogKHJlLSlhZGQgZG9tYWluIHRvIHRoZSBwZW5hbHR5IGV4dHJhcSAqLw0KICAgICAgICAgICAg IGV4dHJhcV9hZGRfc29ydF91cGRhdGUoaW5mLT52Y3B1LCBFWFRSQV9QRU5fUSwgMCk7DQogICAg ICAgICB9DQogICAgIH0NCiANCi0gICAgLypnaXZlIGl0IGEgZnJlc2ggc2xpY2UgaW4gdGhlIG5l eHQgcGVyaW9kISovDQorICAgIC8qIEdpdmUgaXQgYSBmcmVzaCBzbGljZSBpbiB0aGUgbmV4dCBw ZXJpb2QhICovDQogICAgIGluZi0+Y3B1dGltZSA9IDA7DQogfQ0KIA0KIA0KIHN0YXRpYyB2b2lk IHVuYmxvY2tfbG9uZ19jb25zX2Ioc3RydWN0IHNlZGZfdmNwdV9pbmZvKiBpbmYsc190aW1lX3Qg bm93KQ0KIHsNCi0gICAgLypDb25zZXJ2YXRpdmUgMmIqLw0KLSAgICAvKlRyZWF0IHRoZSB1bmJs b2NraW5nIHRpbWUgYXMgYSBzdGFydCBvZiBhIG5ldyBwZXJpb2QgKi8NCisgICAgLyogQ29uc2Vy dmF0aXZlIDJiICovDQorDQorICAgIC8qIFRyZWF0IHRoZSB1bmJsb2NraW5nIHRpbWUgYXMgYSBz dGFydCBvZiBhIG5ldyBwZXJpb2QgKi8NCiAgICAgaW5mLT5kZWFkbF9hYnMgPSBub3cgKyBpbmYt PnBlcmlvZDsNCiAgICAgaW5mLT5jcHV0aW1lID0gMDsNCiB9DQpAQCAtMTA2OCwxNSArMTAzOCwx NyBAQCBzdGF0aWMgaW5saW5lIGludCBnZXRfcnVuX3R5cGUoc3RydWN0IHZjDQogfQ0KIA0KIA0K LS8qQ29tcGFyZXMgdHdvIGRvbWFpbnMgaW4gdGhlIHJlbGF0aW9uIG9mIHdoZXRoZXIgdGhlIG9u ZSBpcyBhbGxvd2VkIHRvDQotICBpbnRlcnJ1cHQgdGhlIG90aGVycyBleGVjdXRpb24uDQotICBJ dCByZXR1cm5zIHRydWUgKCE9MCkgaWYgYSBzd2l0Y2ggdG8gdGhlIG90aGVyIGRvbWFpbiBpcyBn b29kLg0KLSAgQ3VycmVudCBQcmlvcml0eSBzY2hlbWUgaXMgYXMgZm9sbG93czoNCi0gICBFREYg PiBMMCAocGVuYWx0eSBiYXNlZCkgZXh0cmEtdGltZSA+IA0KLSAgIEwxICh1dGlsaXphdGlvbikg ZXh0cmEtdGltZSA+IGlkbGUtZG9tYWluDQotICBJbiB0aGUgc2FtZSBjbGFzcyBwcmlvcml0aWVz IGFyZSBhc3NpZ25lZCBhcyBmb2xsb3dpbmc6DQotICAgRURGOiBlYXJseSBkZWFkbGluZSA+IGxh dGUgZGVhZGxpbmUNCi0gICBMMCBleHRyYS10aW1lOiBsb3dlciBzY29yZSA+IGhpZ2hlciBzY29y ZSovDQorLyoNCisgKiBDb21wYXJlcyB0d28gZG9tYWlucyBpbiB0aGUgcmVsYXRpb24gb2Ygd2hl dGhlciB0aGUgb25lIGlzIGFsbG93ZWQgdG8NCisgKiBpbnRlcnJ1cHQgdGhlIG90aGVycyBleGVj dXRpb24uDQorICogSXQgcmV0dXJucyB0cnVlICghPTApIGlmIGEgc3dpdGNoIHRvIHRoZSBvdGhl ciBkb21haW4gaXMgZ29vZC4NCisgKiBDdXJyZW50IFByaW9yaXR5IHNjaGVtZSBpcyBhcyBmb2xs b3dzOg0KKyAqICBFREYgPiBMMCAocGVuYWx0eSBiYXNlZCkgZXh0cmEtdGltZSA+IA0KKyAqICBM MSAodXRpbGl6YXRpb24pIGV4dHJhLXRpbWUgPiBpZGxlLWRvbWFpbg0KKyAqIEluIHRoZSBzYW1l IGNsYXNzIHByaW9yaXRpZXMgYXJlIGFzc2lnbmVkIGFzIGZvbGxvd2luZzoNCisgKiAgRURGOiBl YXJseSBkZWFkbGluZSA+IGxhdGUgZGVhZGxpbmUNCisgKiAgTDAgZXh0cmEtdGltZTogbG93ZXIg c2NvcmUgPiBoaWdoZXIgc2NvcmUNCisgKi8NCiBzdGF0aWMgaW5saW5lIGludCBzaG91bGRfc3dp dGNoKHN0cnVjdCB2Y3B1ICpjdXIsDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz dHJ1Y3QgdmNwdSAqb3RoZXIsDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzX3Rp bWVfdCBub3cpDQpAQCAtMTA4NSwyNiArMTA1NywyNSBAQCBzdGF0aWMgaW5saW5lIGludCBzaG91 bGRfc3dpdGNoKHN0cnVjdCB2DQogICAgIGN1cl9pbmYgICA9IEVET01fSU5GTyhjdXIpOw0KICAg ICBvdGhlcl9pbmYgPSBFRE9NX0lORk8ob3RoZXIpOw0KICANCi0gICAgLyogQ2hlY2sgd2hldGhl ciB3ZSBuZWVkIHRvIG1ha2UgYW4gZWFybGllciBzY2hlZHVsaW5nIGRlY2lzaW9uLiAqLw0KKyAg ICAvKiBDaGVjayB3aGV0aGVyIHdlIG5lZWQgdG8gbWFrZSBhbiBlYXJsaWVyIHNjaGVkdWxpbmcg ZGVjaXNpb24gKi8NCiAgICAgaWYgKCBQRVJJT0RfQkVHSU4ob3RoZXJfaW5mKSA8IA0KICAgICAg ICAgIENQVV9JTkZPKG90aGVyLT5wcm9jZXNzb3IpLT5jdXJyZW50X3NsaWNlX2V4cGlyZXMgKQ0K ICAgICAgICAgcmV0dXJuIDE7DQogDQotICAgIC8qIE5vIHRpbWluZy1iYXNlZCBzd2l0Y2hlcyBu ZWVkIHRvIGJlIHRha2VuIGludG8gYWNjb3VudCBoZXJlLiAqLw0KKyAgICAvKiBObyB0aW1pbmct YmFzZWQgc3dpdGNoZXMgbmVlZCB0byBiZSB0YWtlbiBpbnRvIGFjY291bnQgaGVyZSAqLw0KICAg ICBzd2l0Y2ggKCBnZXRfcnVuX3R5cGUoY3VyKSApDQogICAgIHsNCiAgICAgY2FzZSBET01BSU5f RURGOg0KLSAgICAgICAgLyogRG8gbm90IGludGVycnVwdCBhIHJ1bm5pbmcgRURGIGRvbWFpbi4g Ki8NCisgICAgICAgIC8qIERvIG5vdCBpbnRlcnJ1cHQgYSBydW5uaW5nIEVERiBkb21haW4gKi8N CiAgICAgICAgIHJldHVybiAwOw0KICAgICBjYXNlIERPTUFJTl9FWFRSQV9QRU46DQotICAgICAg ICAvKiBDaGVjayB3aGV0aGVyIHdlIGFsc28gd2FudCB0aGUgTDAgZXgtcSB3aXRoIGxvd2VyIHNj b3JlLiAqLw0KKyAgICAgICAgLyogQ2hlY2sgd2hldGhlciB3ZSBhbHNvIHdhbnQgdGhlIEwwIGV4 LXEgd2l0aCBsb3dlciBzY29yZSAqLw0KICAgICAgICAgcmV0dXJuICgob3RoZXJfaW5mLT5zdGF0 dXMgJiBFWFRSQV9XQU5UX1BFTl9RKSAmJg0KICAgICAgICAgICAgICAgICAob3RoZXJfaW5mLT5z Y29yZVtFWFRSQV9QRU5fUV0gPCANCiAgICAgICAgICAgICAgICAgIGN1cl9pbmYtPnNjb3JlW0VY VFJBX1BFTl9RXSkpOw0KICAgICBjYXNlIERPTUFJTl9FWFRSQV9VVElMOg0KICAgICAgICAgLyog Q2hlY2sgd2hldGhlciB3ZSB3YW50IHRoZSBMMCBleHRyYXEuIERvbid0DQotICAgICAgICAgKiBz d2l0Y2ggaWYgYm90aCBkb21haW5zIHdhbnQgTDEgZXh0cmFxLg0KLSAgICAgICAgICovDQorICAg ICAgICAgKiBzd2l0Y2ggaWYgYm90aCBkb21haW5zIHdhbnQgTDEgZXh0cmFxLiAqLw0KICAgICAg ICAgcmV0dXJuICEhKG90aGVyX2luZi0+c3RhdHVzICYgRVhUUkFfV0FOVF9QRU5fUSk7DQogICAg IGNhc2UgRE9NQUlOX0lETEU6DQogICAgICAgICByZXR1cm4gMTsNCkBAIC0xMTE4LDE4ICsxMDg5 LDExIEBAIHN0YXRpYyB2b2lkIHNlZGZfd2FrZShjb25zdCBzdHJ1Y3Qgc2NoZWQNCiAgICAgc190 aW1lX3QgICAgICAgICAgICAgIG5vdyA9IE5PVygpOw0KICAgICBzdHJ1Y3Qgc2VkZl92Y3B1X2lu Zm8qIGluZiA9IEVET01fSU5GTyhkKTsNCiANCi0gICAgUFJJTlQoMywgInNlZGZfd2FrZSB3YXMg Y2FsbGVkLCBkb21haW4taWQgJWkuJWlcbiIsZC0+ZG9tYWluLT5kb21haW5faWQsDQotICAgICAg ICAgIGQtPnZjcHVfaWQpOw0KLQ0KICAgICBpZiAoIHVubGlrZWx5KGlzX2lkbGVfdmNwdShkKSkg KQ0KICAgICAgICAgcmV0dXJuOw0KICAgIA0KICAgICBpZiAoIHVubGlrZWx5KF9fdGFza19vbl9x dWV1ZShkKSkgKQ0KLSAgICB7DQotICAgICAgICBQUklOVCgzLCJcdGRvbWFpbiAlaS4laSBpcyBh bHJlYWR5IGluIHNvbWUgcXVldWVcbiIsDQotICAgICAgICAgICAgICBkLT5kb21haW4tPmRvbWFp bl9pZCwgZC0+dmNwdV9pZCk7DQogICAgICAgICByZXR1cm47DQotICAgIH0NCiANCiAgICAgQVNT RVJUKCFzZWRmX3J1bm5hYmxlKGQpKTsNCiAgICAgaW5mLT5zdGF0dXMgJj0gflNFREZfQVNMRUVQ Ow0KQEAgLTExMzgsMjggKzExMDIsMjUgQEAgc3RhdGljIHZvaWQgc2VkZl93YWtlKGNvbnN0IHN0 cnVjdCBzY2hlZA0KICANCiAgICAgaWYgKCB1bmxpa2VseShpbmYtPmRlYWRsX2FicyA9PSAwKSAp DQogICAgIHsNCi0gICAgICAgIC8qaW5pdGlhbCBzZXR1cCBvZiB0aGUgZGVhZGxpbmUqLw0KKyAg ICAgICAgLyogSW5pdGlhbCBzZXR1cCBvZiB0aGUgZGVhZGxpbmUgKi8NCiAgICAgICAgIGluZi0+ ZGVhZGxfYWJzID0gbm93ICsgaW5mLT5zbGljZTsNCiAgICAgfQ0KICAgDQotICAgIFBSSU5UKDMs ICJ3YWtpbmcgdXAgZG9tYWluICVpLiVpIChkZWFkbD0gJSJQUkl1NjQiIHBlcmlvZD0gJSJQUkl1 NjQNCi0gICAgICAgICAgIm5vdz0gJSJQUkl1NjQiKVxuIiwNCi0gICAgICAgICAgZC0+ZG9tYWlu LT5kb21haW5faWQsIGQtPnZjcHVfaWQsIGluZi0+ZGVhZGxfYWJzLCBpbmYtPnBlcmlvZCwgbm93 KTsNCi0NCiAjaWZkZWYgU0VERl9TVEFUUyANCiAgICAgaW5mLT5ibG9ja190b3QrKzsNCiAjZW5k aWYNCiANCiAgICAgaWYgKCB1bmxpa2VseShub3cgPCBQRVJJT0RfQkVHSU4oaW5mKSkgKQ0KICAg ICB7DQotICAgICAgICBQUklOVCg0LCJleHRyYXRpbWUgdW5ibG9ja1xuIik7DQotICAgICAgICAv KiB1bmJsb2NraW5nIGluIGV4dHJhLXRpbWUhICovDQorICAgICAgICAvKiBVbmJsb2NraW5nIGlu IGV4dHJhLXRpbWUhICovDQogICAgICAgICBpZiAoIGluZi0+c3RhdHVzICYgRVhUUkFfV0FOVF9Q RU5fUSApDQogICAgICAgICB7DQotICAgICAgICAgICAgLyp3ZSBoYXZlIGEgZG9tYWluIHRoYXQg d2FudHMgY29tcGVuc2F0aW9uDQotICAgICAgICAgICAgICBmb3IgYmxvY2sgcGVuYWx0eSBhbmQg ZGlkIGp1c3QgYmxvY2sgaW4NCi0gICAgICAgICAgICAgIGl0cyBjb21wZW5zYXRpb24gdGltZS4g R2l2ZSBpdCBhbm90aGVyDQotICAgICAgICAgICAgICBjaGFuY2UhKi8NCisgICAgICAgICAgICAv Kg0KKyAgICAgICAgICAgICAqIFdlIGhhdmUgYSBkb21haW4gdGhhdCB3YW50cyBjb21wZW5zYXRp b24NCisgICAgICAgICAgICAgKiBmb3IgYmxvY2sgcGVuYWx0eSBhbmQgZGlkIGp1c3QgYmxvY2sg aW4NCisgICAgICAgICAgICAgKiBpdHMgY29tcGVuc2F0aW9uIHRpbWUuIEdpdmUgaXQgYW5vdGhl cg0KKyAgICAgICAgICAgICAqIGNoYW5jZSENCisgICAgICAgICAgICAgKi8NCiAgICAgICAgICAg ICBleHRyYXFfYWRkX3NvcnRfdXBkYXRlKGQsIEVYVFJBX1BFTl9RLCAwKTsNCiAgICAgICAgIH0N CiAgICAgICAgIGV4dHJhcV9jaGVja19hZGRfdW5ibG9ja2VkKGQsIDApOw0KQEAgLTExNjgsOCAr MTEyOSw3IEBAIHN0YXRpYyB2b2lkIHNlZGZfd2FrZShjb25zdCBzdHJ1Y3Qgc2NoZWQNCiAgICAg eyAgDQogICAgICAgICBpZiAoIG5vdyA8IGluZi0+ZGVhZGxfYWJzICkNCiAgICAgICAgIHsNCi0g ICAgICAgICAgICBQUklOVCg0LCJzaG9ydCB1bmJsb2NraW5nXG4iKTsNCi0gICAgICAgICAgICAv KnNob3J0IGJsb2NraW5nKi8NCisgICAgICAgICAgICAvKiBTaG9ydCBibG9ja2luZyAqLw0KICNp ZmRlZiBTRURGX1NUQVRTDQogICAgICAgICAgICAgaW5mLT5zaG9ydF9ibG9ja190b3QrKzsNCiAj ZW5kaWYNCkBAIC0xMTc5LDggKzExMzksNyBAQCBzdGF0aWMgdm9pZCBzZWRmX3dha2UoY29uc3Qg c3RydWN0IHNjaGVkDQogICAgICAgICB9DQogICAgICAgICBlbHNlDQogICAgICAgICB7DQotICAg ICAgICAgICAgUFJJTlQoNCwibG9uZyB1bmJsb2NraW5nXG4iKTsNCi0gICAgICAgICAgICAvKmxv bmcgdW5ibG9ja2luZyovDQorICAgICAgICAgICAgLyogTG9uZyB1bmJsb2NraW5nICovDQogI2lm ZGVmIFNFREZfU1RBVFMNCiAgICAgICAgICAgICBpbmYtPmxvbmdfYmxvY2tfdG90Kys7DQogI2Vu ZGlmDQpAQCAtMTE5MCwyNCArMTE0OSwxMyBAQCBzdGF0aWMgdm9pZCBzZWRmX3dha2UoY29uc3Qg c3RydWN0IHNjaGVkDQogICAgICAgICB9DQogICAgIH0NCiANCi0gICAgUFJJTlQoMywgIndva2Ug dXAgZG9tYWluICVpLiVpIChkZWFkbD0gJSJQUkl1NjQiIHBlcmlvZD0gJSJQUkl1NjQNCi0gICAg ICAgICAgIm5vdz0gJSJQUkl1NjQiKVxuIiwNCi0gICAgICAgICAgZC0+ZG9tYWluLT5kb21haW5f aWQsIGQtPnZjcHVfaWQsIGluZi0+ZGVhZGxfYWJzLA0KLSAgICAgICAgICBpbmYtPnBlcmlvZCwg bm93KTsNCi0NCiAgICAgaWYgKCBQRVJJT0RfQkVHSU4oaW5mKSA+IG5vdyApDQotICAgIHsNCiAg ICAgICAgIF9fYWRkX3RvX3dhaXRxdWV1ZV9zb3J0KGQpOw0KLSAgICAgICAgUFJJTlQoMywiYWRk ZWQgdG8gd2FpdHFcbiIpOw0KLSAgICB9DQogICAgIGVsc2UNCi0gICAgew0KICAgICAgICAgX19h ZGRfdG9fcnVucXVldWVfc29ydChkKTsNCi0gICAgICAgIFBSSU5UKDMsImFkZGVkIHRvIHJ1bnFc biIpOw0KLSAgICB9DQogIA0KICNpZmRlZiBTRURGX1NUQVRTDQotICAgIC8qZG8gc29tZSBzdGF0 aXN0aWNzIGhlcmUuLi4qLw0KKyAgICAvKiBEbyBzb21lIHN0YXRpc3RpY3MgaGVyZS4uLiAqLw0K ICAgICBpZiAoIGluZi0+YmxvY2tfYWJzICE9IDAgKQ0KICAgICB7DQogICAgICAgICBpbmYtPmJs b2NrX3RpbWVfdG90ICs9IG5vdyAtIGluZi0+YmxvY2tfYWJzOw0KQEAgLTEyMTYsMTIgKzExNjQs MTQgQEAgc3RhdGljIHZvaWQgc2VkZl93YWtlKGNvbnN0IHN0cnVjdCBzY2hlZA0KICAgICB9DQog I2VuZGlmDQogDQotICAgIC8qc2FuaXR5IGNoZWNrOiBtYWtlIHN1cmUgZWFjaCBleHRyYS1hd2Fy ZSBkb21haW4gSVMgb24gdGhlIHV0aWwtcSEqLw0KKyAgICAvKiBTYW5pdHkgY2hlY2s6IG1ha2Ug c3VyZSBlYWNoIGV4dHJhLWF3YXJlIGRvbWFpbiBJUyBvbiB0aGUgdXRpbC1xISAqLw0KICAgICBB U1NFUlQoSU1QTFkoaW5mLT5zdGF0dXMgJiBFWFRSQV9BV0FSRSwgZXh0cmFxX29uKGQsIEVYVFJB X1VUSUxfUSkpKTsNCiAgICAgQVNTRVJUKF9fdGFza19vbl9xdWV1ZShkKSk7DQotICAgIC8qY2hl Y2sgd2hldGhlciB0aGUgYXdha2VuZWQgdGFzayBuZWVkcyB0byBpbnZva2UgdGhlIGRvX3NjaGVk dWxlDQotICAgICAgcm91dGluZS4gVHJ5IHRvIGF2b2lkIHVubmVjZXNzYXJ5IHJ1bnMgYnV0Og0K LSAgICAgIFNhdmUgYXBwcm94aW1hdGlvbjogQWx3YXlzIHN3aXRjaCB0byBzY2hlZHVsZXIhKi8N CisgICAgLyoNCisgICAgICogQ2hlY2sgd2hldGhlciB0aGUgYXdha2VuZWQgdGFzayBuZWVkcyB0 byBpbnZva2UgdGhlIGRvX3NjaGVkdWxlDQorICAgICAqIHJvdXRpbmUuIFRyeSB0byBhdm9pZCB1 bm5lY2Vzc2FyeSBydW5zIGJ1dDoNCisgICAgICogU2F2ZSBhcHByb3hpbWF0aW9uOiBBbHdheXMg c3dpdGNoIHRvIHNjaGVkdWxlciENCisgICAgICovDQogICAgIEFTU0VSVChkLT5wcm9jZXNzb3Ig Pj0gMCk7DQogICAgIEFTU0VSVChkLT5wcm9jZXNzb3IgPCBucl9jcHVfaWRzKTsNCiAgICAgQVNT RVJUKHBlcl9jcHUoc2NoZWR1bGVfZGF0YSwgZC0+cHJvY2Vzc29yKS5jdXJyKTsNCkBAIC0xMjY2 LDcgKzEyMTYsNyBAQCBzdGF0aWMgdm9pZCBzZWRmX2R1bXBfZG9tYWluKHN0cnVjdCB2Y3B1DQog fQ0KIA0KIA0KLS8qIGR1bXBzIGFsbCBkb21haW5zIG9uIHRoZSBzcGVjaWZpZWQgY3B1ICovDQor LyogRHVtcHMgYWxsIGRvbWFpbnMgb24gdGhlIHNwZWNpZmllZCBjcHUgKi8NCiBzdGF0aWMgdm9p ZCBzZWRmX2R1bXBfY3B1X3N0YXRlKGNvbnN0IHN0cnVjdCBzY2hlZHVsZXIgKm9wcywgaW50IGkp DQogew0KICAgICBzdHJ1Y3QgbGlzdF9oZWFkICAgICAgKmxpc3QsICpxdWV1ZSwgKnRtcDsNCkBA IC0xMzQxLDE2ICsxMjkxLDE4IEBAIHN0YXRpYyB2b2lkIHNlZGZfZHVtcF9jcHVfc3RhdGUoY29u c3Qgc3QNCiB9DQogDQogDQotLyogQWRqdXN0cyBwZXJpb2RzIGFuZCBzbGljZXMgb2YgdGhlIGRv bWFpbnMgYWNjb3JkaW5nbHkgdG8gdGhlaXIgd2VpZ2h0cy4gKi8NCisvKiBBZGp1c3RzIHBlcmlv ZHMgYW5kIHNsaWNlcyBvZiB0aGUgZG9tYWlucyBhY2NvcmRpbmdseSB0byB0aGVpciB3ZWlnaHRz ICovDQogc3RhdGljIGludCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBjcHVwb29sICpjLCBp bnQgbnJfY3B1cywgaW50ICpzdW13LCBzX3RpbWVfdCAqc3VtdCkNCiB7DQogICAgIHN0cnVjdCB2 Y3B1ICpwOw0KICAgICBzdHJ1Y3QgZG9tYWluICAgICAgKmQ7DQogICAgIHVuc2lnbmVkIGludCAg ICAgICAgY3B1Ow0KIA0KLSAgICAvKiBTdW0gYWNyb3NzIGFsbCB3ZWlnaHRzLiBOb3RpY2UgdGhh dCBubyBydW5xIGxvY2tpbmcgaXMgbmVlZGVkDQorICAgIC8qDQorICAgICAqIFN1bSBhY3Jvc3Mg YWxsIHdlaWdodHMuIE5vdGljZSB0aGF0IG5vIHJ1bnEgbG9ja2luZyBpcyBuZWVkZWQNCiAgICAg ICogaGVyZTogdGhlIGNhbGxlciBob2xkcyBzZWRmX3ByaXZfaW5mby5sb2NrIGFuZCB3ZSdyZSBu b3QgY2hhbmdpbmcNCi0gICAgICogYW55dGhpbmcgdGhhdCBpcyBhY2Nlc3NlZCBkdXJpbmcgc2No ZWR1bGluZy4gKi8NCisgICAgICogYW55dGhpbmcgdGhhdCBpcyBhY2Nlc3NlZCBkdXJpbmcgc2No ZWR1bGluZy4NCisgICAgICovDQogICAgIHJjdV9yZWFkX2xvY2soJmRvbWxpc3RfcmVhZF9sb2Nr KTsNCiAgICAgZm9yX2VhY2hfZG9tYWluX2luX2NwdXBvb2woIGQsIGMgKQ0KICAgICB7DQpAQCAt MTM2NSwxMSArMTMxNywxNCBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0X3dlaWdodHMoc3RydWN0 IGNwDQogICAgICAgICAgICAgfQ0KICAgICAgICAgICAgIGVsc2UNCiAgICAgICAgICAgICB7DQot ICAgICAgICAgICAgICAgIC8qZG9uJ3QgbW9kaWZ5IGRvbWFpbnMgd2hvIGRvbid0IGhhdmUgYSB3 ZWlnaHQsIGJ1dCBzdW0NCi0gICAgICAgICAgICAgICAgICB1cCB0aGUgdGltZSB0aGV5IG5lZWQs IHByb2plY3RlZCB0byBhIFdFSUdIVF9QRVJJT0QsDQotICAgICAgICAgICAgICAgICAgc28gdGhh dCB0aGlzIHRpbWUgaXMgbm90IGdpdmVuIHRvIHRoZSB3ZWlnaHQtZHJpdmVuDQotICAgICAgICAg ICAgICAgICAgZG9tYWlucyovDQotICAgICAgICAgICAgICAgIC8qY2hlY2sgZm9yIG92ZXJmbG93 cyovDQorICAgICAgICAgICAgICAgIC8qDQorICAgICAgICAgICAgICAgICAqIERvbid0IG1vZGlm eSBkb21haW5zIHdobyBkb24ndCBoYXZlIGEgd2VpZ2h0LCBidXQgc3VtDQorICAgICAgICAgICAg ICAgICAqIHVwIHRoZSB0aW1lIHRoZXkgbmVlZCwgcHJvamVjdGVkIHRvIGEgV0VJR0hUX1BFUklP RCwNCisgICAgICAgICAgICAgICAgICogc28gdGhhdCB0aGlzIHRpbWUgaXMgbm90IGdpdmVuIHRv IHRoZSB3ZWlnaHQtZHJpdmVuDQorICAgICAgICAgICAgICAgICAqICBkb21haW5zDQorICAgICAg ICAgICAgICAgICAqLw0KKw0KKyAgICAgICAgICAgICAgICAvKiBDaGVjayBmb3Igb3ZlcmZsb3dz ICovDQogICAgICAgICAgICAgICAgIEFTU0VSVCgoV0VJR0hUX1BFUklPRCA8IFVMT05HX01BWCkg DQogICAgICAgICAgICAgICAgICAgICAgICAmJiAoRURPTV9JTkZPKHApLT5zbGljZV9vcmlnIDwg VUxPTkdfTUFYKSk7DQogICAgICAgICAgICAgICAgIHN1bXRbY3B1XSArPSANCkBAIC0xMzgwLDkg KzEzMzUsMTEgQEAgc3RhdGljIGludCBzZWRmX2FkanVzdF93ZWlnaHRzKHN0cnVjdCBjcA0KICAg ICB9DQogICAgIHJjdV9yZWFkX3VubG9jaygmZG9tbGlzdF9yZWFkX2xvY2spOw0KIA0KLSAgICAv KiBBZGp1c3QgYWxsIHNsaWNlcyAoYW5kIHBlcmlvZHMpIHRvIHRoZSBuZXcgd2VpZ2h0LiBVbmxp a2UgYWJvdmUsIHdlDQorICAgIC8qDQorICAgICAqIEFkanVzdCBhbGwgc2xpY2VzIChhbmQgcGVy aW9kcykgdG8gdGhlIG5ldyB3ZWlnaHQuIFVubGlrZSBhYm92ZSwgd2UNCiAgICAgICogbmVlZCB0 byB0YWtlIHRociBydW5xIGxvY2sgZm9yIHRoZSB2YXJpb3VzIFZDUFVzOiB3ZSdyZSBtb2R5Zmlu Zw0KLSAgICAgKiBzbGljZSBhbmQgcGVyaW9kIHdoaWNoIGFyZSByZWZlcmVuY2VkIGR1cmluZyBz Y2hlZHVsaW5nLiAqLw0KKyAgICAgKiBzbGljZSBhbmQgcGVyaW9kIHdoaWNoIGFyZSByZWZlcmVu Y2VkIGR1cmluZyBzY2hlZHVsaW5nLg0KKyAgICAgKi8NCiAgICAgcmN1X3JlYWRfbG9jaygmZG9t bGlzdF9yZWFkX2xvY2spOw0KICAgICBmb3JfZWFjaF9kb21haW5faW5fY3B1cG9vbCggZCwgYyAp DQogICAgIHsNCkBAIC0xNDEwLDcgKzEzNjcsNyBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0X3dl aWdodHMoc3RydWN0IGNwDQogfQ0KIA0KIA0KLS8qIHNldCBvciBmZXRjaCBkb21haW4gc2NoZWR1 bGluZyBwYXJhbWV0ZXJzICovDQorLyogU2V0IG9yIGZldGNoIGRvbWFpbiBzY2hlZHVsaW5nIHBh cmFtZXRlcnMgKi8NCiBzdGF0aWMgaW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlZHVs ZXIgKm9wcywgc3RydWN0IGRvbWFpbiAqcCwgc3RydWN0IHhlbl9kb21jdGxfc2NoZWR1bGVyX29w ICpvcCkNCiB7DQogICAgIHN0cnVjdCBzZWRmX3ByaXZfaW5mbyAqcHJ2ID0gU0VERl9QUklWKG9w cyk7DQpAQCAtMTQyMSwyMyArMTM3OCwyMiBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0KGNvbnN0 IHN0cnVjdCBzY2hlDQogICAgIHN0cnVjdCB2Y3B1ICp2Ow0KICAgICBpbnQgcmMgPSAwOw0KIA0K LSAgICBQUklOVCgyLCJzZWRmX2FkanVzdCB3YXMgY2FsbGVkLCBkb21haW4taWQgJWkgbmV3IHBl cmlvZCAlIlBSSXU2NCIgIg0KLSAgICAgICAgICAibmV3IHNsaWNlICUiUFJJdTY0IlxubGF0ZW5j eSAlIlBSSXU2NCIgZXh0cmE6JXNcbiIsDQotICAgICAgICAgIHAtPmRvbWFpbl9pZCwgb3AtPnUu c2VkZi5wZXJpb2QsIG9wLT51LnNlZGYuc2xpY2UsDQotICAgICAgICAgIG9wLT51LnNlZGYubGF0 ZW5jeSwgKG9wLT51LnNlZGYuZXh0cmF0aW1lKT8ieWVzIjoibm8iKTsNCi0NCi0gICAgLyogU2Vy aWFsaXplIGFnYWluc3QgdGhlIHBsdWdnYWJsZSBzY2hlZHVsZXIgbG9jayB0byBwcm90ZWN0IGZy b20NCisgICAgLyoNCisgICAgICogU2VyaWFsaXplIGFnYWluc3QgdGhlIHBsdWdnYWJsZSBzY2hl ZHVsZXIgbG9jayB0byBwcm90ZWN0IGZyb20NCiAgICAgICogY29uY3VycmVudCB1cGRhdGVzLiBX ZSBuZWVkIHRvIHRha2UgdGhlIHJ1bnEgbG9jayBmb3IgdGhlIFZDUFVzDQogICAgICAqIGFzIHdl bGwsIHNpbmNlIHdlIGFyZSB0b3VjaGluZyBleHRyYXdlaWdodCwgd2VpZ2h0LCBzbGljZSBhbmQN CiAgICAgICogcGVyaW9kLiBBcyBpbiBzY2hlZF9jcmVkaXQyLmMsIHJ1bnEgbG9ja3MgbmVzdCBp bnNpZGUgdGhlDQotICAgICAqIHBsdWdnYWJsZSBzY2hlZHVsZXIgbG9jay4gKi8NCisgICAgICog cGx1Z2dhYmxlIHNjaGVkdWxlciBsb2NrLg0KKyAgICAgKi8NCiAgICAgc3Bpbl9sb2NrX2lycXNh dmUoJnBydi0+bG9jaywgZmxhZ3MpOw0KIA0KICAgICBpZiAoIG9wLT5jbWQgPT0gWEVOX0RPTUNU TF9TQ0hFRE9QX3B1dGluZm8gKQ0KICAgICB7DQotICAgICAgICAvKiBUaGVzZSBhcmUgdXNlZCBp biBzZWRmX2FkanVzdF93ZWlnaHRzKCkgYnV0IGhhdmUgdG8gYmUgYWxsb2NhdGVkIGluDQorICAg ICAgICAvKg0KKyAgICAgICAgICogVGhlc2UgYXJlIHVzZWQgaW4gc2VkZl9hZGp1c3Rfd2VpZ2h0 cygpIGJ1dCBoYXZlIHRvIGJlIGFsbG9jYXRlZCBpbg0KICAgICAgICAgICogdGhpcyBmdW5jdGlv biwgYXMgd2UgbmVlZCB0byBhdm9pZCBuZXN0aW5nIHhtZW1fcG9vbF9hbGxvYydzIGxvY2sNCi0g ICAgICAgICAqIHdpdGhpbiBvdXIgcHJ2LT5sb2NrLiAqLw0KKyAgICAgICAgICogd2l0aGluIG91 ciBwcnYtPmxvY2suDQorICAgICAgICAgKi8NCiAgICAgICAgIGlmICggIXN1bXcgfHwgIXN1bXQg KQ0KICAgICAgICAgew0KICAgICAgICAgICAgIC8qIENoZWNrIGZvciBlcnJvcnMgaGVyZSwgdGhl IF9nZXRpbmZvIGJyYW5jaCBkb2Vzbid0IGNhcmUgKi8NCkBAIC0xNDQ1LDcgKzE0MDEsNyBAQCBz dGF0aWMgaW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlDQogICAgICAgICAgICAgZ290 byBvdXQ7DQogICAgICAgICB9DQogDQotICAgICAgICAvKiBDaGVjayBmb3Igc2FuZSBwYXJhbWV0 ZXJzLiAqLw0KKyAgICAgICAgLyogQ2hlY2sgZm9yIHNhbmUgcGFyYW1ldGVycyAqLw0KICAgICAg ICAgaWYgKCAhb3AtPnUuc2VkZi5wZXJpb2QgJiYgIW9wLT51LnNlZGYud2VpZ2h0ICkNCiAgICAg ICAgIHsNCiAgICAgICAgICAgICByYyA9IC1FSU5WQUw7DQpAQCAtMTQ1Nyw3ICsxNDEzLDcgQEAg c3RhdGljIGludCBzZWRmX2FkanVzdChjb25zdCBzdHJ1Y3Qgc2NoZQ0KICAgICAgICAgICAgIGlm ICggKG9wLT51LnNlZGYuZXh0cmF0aW1lICYgRVhUUkFfQVdBUkUpICYmDQogICAgICAgICAgICAg ICAgICAoIW9wLT51LnNlZGYucGVyaW9kKSApDQogICAgICAgICAgICAgew0KLSAgICAgICAgICAg ICAgICAvKiBXZWlnaHQtZHJpdmVuIGRvbWFpbnMgd2l0aCBleHRyYXRpbWUgb25seS4gKi8NCisg ICAgICAgICAgICAgICAgLyogV2VpZ2h0LWRyaXZlbiBkb21haW5zIHdpdGggZXh0cmF0aW1lIG9u bHkgKi8NCiAgICAgICAgICAgICAgICAgZm9yX2VhY2hfdmNwdSAoIHAsIHYgKQ0KICAgICAgICAg ICAgICAgICB7DQogICAgICAgICAgICAgICAgICAgICAvKiAoSGVyZSBhbmQgZXZlcnl3aGVyZSBp biB0aGUgZm9sbG93aW5nKSBJUlFzIGFyZSBhbHJlYWR5IG9mZiwNCkBAIC0xNDcyLDcgKzE0Mjgs NyBAQCBzdGF0aWMgaW50IHNlZGZfYWRqdXN0KGNvbnN0IHN0cnVjdCBzY2hlDQogICAgICAgICAg ICAgfQ0KICAgICAgICAgICAgIGVsc2UNCiAgICAgICAgICAgICB7DQotICAgICAgICAgICAgICAg IC8qIFdlaWdodC1kcml2ZW4gZG9tYWlucyB3aXRoIHJlYWwtdGltZSBleGVjdXRpb24uICovDQor ICAgICAgICAgICAgICAgIC8qIFdlaWdodC1kcml2ZW4gZG9tYWlucyB3aXRoIHJlYWwtdGltZSBl eGVjdXRpb24gKi8NCiAgICAgICAgICAgICAgICAgZm9yX2VhY2hfdmNwdSAoIHAsIHYgKSB7DQog ICAgICAgICAgICAgICAgICAgICB2Y3B1X3NjaGVkdWxlX2xvY2sodik7DQogICAgICAgICAgICAg ICAgICAgICBFRE9NX0lORk8odiktPndlaWdodCA9IG9wLT51LnNlZGYud2VpZ2h0Ow0KQEAgLTE0 OTUsNyArMTQ1MSw3IEBAIHN0YXRpYyBpbnQgc2VkZl9hZGp1c3QoY29uc3Qgc3RydWN0IHNjaGUN CiAgICAgICAgICAgICAgICAgZ290byBvdXQ7DQogICAgICAgICAgICAgfQ0KIA0KLSAgICAgICAg ICAgIC8qIFRpbWUtZHJpdmVuIGRvbWFpbnMuICovDQorICAgICAgICAgICAgLyogVGltZS1kcml2 ZW4gZG9tYWlucyAqLw0KICAgICAgICAgICAgIGZvcl9lYWNoX3ZjcHUgKCBwLCB2ICkNCiAgICAg ICAgICAgICB7DQogICAgICAgICAgICAgICAgIHZjcHVfc2NoZWR1bGVfbG9jayh2KTsNCkBAIC0x NTQ1LDcgKzE1MDEsNiBAQCBvdXQ6DQogICAgIHhmcmVlKHN1bXQpOw0KICAgICB4ZnJlZShzdW13 KTsNCiANCi0gICAgUFJJTlQoMiwic2VkZl9hZGp1c3RfZmluaXNoZWQgd2l0aCByZXR1cm4gY29k ZSAlZFxuIiwgcmMpOw0KICAgICByZXR1cm4gcmM7DQogfQ0KIA0K --=-Q+nO0nZUPH9ih0IDSLo0-- --=-BVBDbEUzgZPrsy4cOGLY 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) iEYEABECAAYFAk8Fvu0ACgkQk4XaBE3IOsR1VwCfcsuEozHwG9FojBY+UvcmkcD1 v9IAnA3Ue47AV827f9NpybP7AUye4eh1 =QtEa -----END PGP SIGNATURE----- --=-BVBDbEUzgZPrsy4cOGLY-- --===============0162675564886136273== 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 --===============0162675564886136273==--