From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tetsu Yamamoto Subject: Re: [PATCH] xm reboot/shutdown/sysrq to HVM domain Date: Fri, 27 Oct 2006 18:54:58 +0900 Message-ID: <4541D772.7070100@jp.fujitsu.com> References: <4526005B.1020906@jp.fujitsu.com> <20061006095902.GA2767@cam.ac.uk> <452B4F1A.4050109@jp.fujitsu.com> <20061012105108.GA3056@cam.ac.uk> <4535F956.4040706@jp.fujitsu.com> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="------------090506020802090507080907" Return-path: In-Reply-To: <4535F956.4040706@jp.fujitsu.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xensource.com Errors-To: xen-devel-bounces@lists.xensource.com To: Steven Smith , xen-devel@lists.xensource.com, sos22@srcf.ucam.org List-Id: xen-devel@lists.xenproject.org This is a multi-part message in MIME format. --------------090506020802090507080907 Content-Type: text/plain; charset=ISO-2022-JP Content-Transfer-Encoding: 7bit Hi, Sorry, the previous patch had a problem on dom0 boot. I have modified the patch to fix it and tested xm reboot/shutdown/sysrq to both of PV and HVM domain. To make reboot on HVM domain work correctly, the following patch is needed: http://lists.xensource.com/archives/html/xen-devel/2006-10/msg01184.html Regards, Tetsu Yamamoto Signed-off-by: Tetsu Yamamoto Tetsu Yamamoto wrote: > Hi Steven, > > Thank you for your comments. > > The attached is modified patch based on your comments. > > The functions which can not be used from the module on HVM domain are > moved to the new file machine_reboot.c, and several #ifdefs are removed. > However, reboot.c still has two parts of #ifdef CONFIG_XEN because some > functions called in common functions are not EXPORT_SYMBOL: > - sys_reboot > - Some functions called in __do_suspend > > Regards, > > Tetsu Yamamoto > > Signed-off-by: Tetsu Yamamoto > > Steven Smith wrote: >>>>> This patch enhances 'xm reboot'/'xm shutdown' commands to >>>>> reboot/shutdown guest Linux on HVM domain as gracefully as para-Linux. >>>>> In addtion, sysrq key signal can be sent to HVM domain by 'xm sysrq' >>>>> command. >>>> Thanks, that's really useful. I have a couple of comments about the >>>> patch, though: >>>> >>>> -- It looks like you had some problems with ctrl_alt_del(), and instead >>>> used kill_proc(cad_pid, SIGINT, 1). What was the reason for this? >>> The symbol ctrl_alt_del() can't be found when it is used in loadable >>> module. On build, the warning message is shown that ctrl_alt_del() is >>> undefined, and on loading, the error message is shown that it is unknown >>> symbol. I'm not sure why this happens, but I tried kill_proc(), which >>> is called in ctrl_alt_del(), it works correctly. >> Ah, okay, ctrl_alt_del isn't an EXPORT_SYMBOL. That's unfortunate, >> and this looks like a sensible work-around. >> >>>> -- You've introduced a lot of #ifdefs into reboot.c. It might be >>>> easier to just split the file in two; did you look at this at all? >>> reboot.c has common process to deal with reboot/shutdown/sysrq for >>> para-linux (built in kernel) and full-linux (loadable module), so I >>> think that it would be better to be one file in consideration of code >>> maintenance. >> I'm not talking about duplicating the code. As far as I can see, you >> share the following functions with PV reboot.c: >> >> -- shutdown_process >> -- __shutdown_handler >> -- shutdown_handler >> -- sysrq_handler >> -- setup_shutdown_event >> -- setup_shutdown_watcher >> >> You don't share: >> >> -- machine_emergency_restart >> -- machine_restart >> -- machine_halt >> -- machine_power_off >> -- switch_idle_mm >> -- pre_suspend >> -- post_suspend >> -- __do_suspend >> -- kthread_create_on_cpu >> >> To put it another way, your patch #if's out more than half the file. >> Given that, I think the code would be more maintainable if you moved >> machine_* and __do_suspend to a new file, perhaps machine_reboot.c. >> >>>> -- You set reboot_module from within a xenbus transaction. I don't >>>> think that's necessary, since xenbus_writes are supposed to be >>>> atomic anyway. >>> The reason why I use xenbus_write is that I could not find other >>> interface to write xenstore through xenbus module for HVM. I'm not sure >>> which interface you suggest to use, but for example, xb_write() is not >>> exported, so it can not be called from reboot module. If I should use >>> other interface, please let me know. >> I'm not objecting to the use of xenbus_write, but the use of >> xenbus_transaction_start: you're only doing one write, so you can just >> go xenbus_write(XBT_NULL, "control", "reboot_module", "installed") >> rather than having the loop in setup_shutdown_event. >> >> I'm also not sure why this is #ifndef CONFIG_XEN. It seems like it >> would be a good idea to set reboot_module in PV domains as well, just >> for consistency. >> >>> +#ifndef CONFIG_XEN >>> +MODULE_LICENSE("Dual BSD/GPL"); >>> +#endif /* !CONFIG_XEN */ >> Does this actually need the #ifdefs? If we're CONFIG_XEN, we're not a >> module, so MODULE_LICENSE gets preprocessored away, doesn't it? >> >>> static int shutdown_process(void *__unused) >>> { >>> @@ -222,12 +232,17 @@ static int shutdown_process(void *__unus >>> >>> if ((shutting_down == SHUTDOWN_POWEROFF) || >>> (shutting_down == SHUTDOWN_HALT)) { >>> +#ifdef CONFIG_XEN >>> if (execve("/sbin/poweroff", poweroff_argv, envp) < 0) { >>> sys_reboot(LINUX_REBOOT_MAGIC1, >>> LINUX_REBOOT_MAGIC2, >>> LINUX_REBOOT_CMD_POWER_OFF, >>> NULL); >>> } >>> +#else /* !CONFIG_XEN */ >>> + call_usermodehelper_keys("/sbin/poweroff", poweroff_argv, envp, > NULL, 0); >>> + >>> +#endif /* !CONFIG_XEN */ >> Hmm... it might make sense to use call_usermodehelper_keys in the >> CONFIG_XEN case. Did you try that? >> >>> static void __shutdown_handler(void *unused) >>> { >>> int err; >>> >>> +#ifdef CONFIG_XEN >>> if (shutting_down != SHUTDOWN_SUSPEND) >>> err = kernel_thread(shutdown_process, NULL, >>> CLONE_FS | CLONE_FILES); >>> else >>> err = kthread_create_on_cpu(__do_suspend, NULL, "suspend", 0); >>> >>> +#else /* !CONFIG_XEN */ >>> + err = kernel_thread(shutdown_process, NULL, >>> + CLONE_FS | CLONE_FILES); >>> +#endif /* !CONFIG_XEN */ >>> + >> I don't understand why this was necessary. Surely __do_suspend just >> returns an error if called from non-CONFIG_XEN? >> >> Steven. > > > > ------------------------------------------------------------------------ > > diff -r 38f9bd7a4ce6 linux-2.6-xen-sparse/drivers/xen/core/Makefile > --- a/linux-2.6-xen-sparse/drivers/xen/core/Makefile Tue Oct 03 11:39:22 2006 +0100 > +++ b/linux-2.6-xen-sparse/drivers/xen/core/Makefile Mon Oct 16 19:43:51 2006 +0900 > @@ -9,5 +9,5 @@ obj-$(CONFIG_HOTPLUG_CPU) += cpu_hotplug > obj-$(CONFIG_HOTPLUG_CPU) += cpu_hotplug.o > obj-$(CONFIG_XEN_SYSFS) += xen_sysfs.o > obj-$(CONFIG_XEN_SKBUFF) += skbuff.o > -obj-$(CONFIG_XEN_REBOOT) += reboot.o > +obj-$(CONFIG_XEN_REBOOT) += reboot.o machine_reboot.o > obj-$(CONFIG_XEN_SMPBOOT) += smpboot.o > diff -r 38f9bd7a4ce6 linux-2.6-xen-sparse/drivers/xen/core/reboot.c > --- a/linux-2.6-xen-sparse/drivers/xen/core/reboot.c Tue Oct 03 11:39:22 2006 +0100 > +++ b/linux-2.6-xen-sparse/drivers/xen/core/reboot.c Wed Oct 18 15:46:31 2006 +0900 > @@ -1,215 +1,19 @@ > #define __KERNEL_SYSCALLS__ > #include > #include > -#include > #include > #include > #include > #include > -#include > -#include > -#include > -#include > #include > -#include > #include > -#include > #include > -#include > -#include > -#include > +#include > > -extern void ctrl_alt_del(void); > +MODULE_LICENSE("Dual BSD/GPL"); > > -#define SHUTDOWN_INVALID -1 > -#define SHUTDOWN_POWEROFF 0 > -#define SHUTDOWN_SUSPEND 2 > -/* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only > - * report a crash, not be instructed to crash! > - * HALT is the same as POWEROFF, as far as we're concerned. The tools use > - * the distinction when we return the reason code to them. > - */ > -#define SHUTDOWN_HALT 4 > - > -#if defined(__i386__) || defined(__x86_64__) > - > -/* > - * Power off function, if any > - */ > -void (*pm_power_off)(void); > -EXPORT_SYMBOL(pm_power_off); > - > -void machine_emergency_restart(void) > -{ > - /* We really want to get pending console data out before we die. */ > - xencons_force_flush(); > - HYPERVISOR_shutdown(SHUTDOWN_reboot); > -} > - > -void machine_restart(char * __unused) > -{ > - machine_emergency_restart(); > -} > - > -void machine_halt(void) > -{ > - machine_power_off(); > -} > - > -void machine_power_off(void) > -{ > - /* We really want to get pending console data out before we die. */ > - xencons_force_flush(); > - if (pm_power_off) > - pm_power_off(); > - HYPERVISOR_shutdown(SHUTDOWN_poweroff); > -} > - > -int reboot_thru_bios = 0; /* for dmi_scan.c */ > -EXPORT_SYMBOL(machine_restart); > -EXPORT_SYMBOL(machine_halt); > -EXPORT_SYMBOL(machine_power_off); > - > -#endif /* defined(__i386__) || defined(__x86_64__) */ > - > -/****************************************************************************** > - * Stop/pickle callback handling. > - */ > - > -/* Ignore multiple shutdown requests. */ > -static int shutting_down = SHUTDOWN_INVALID; > static void __shutdown_handler(void *unused); > static DECLARE_WORK(shutdown_work, __shutdown_handler, NULL); > - > -#if defined(__i386__) || defined(__x86_64__) > - > -/* Ensure we run on the idle task page tables so that we will > - switch page tables before running user space. This is needed > - on architectures with separate kernel and user page tables > - because the user page table pointer is not saved/restored. */ > -static void switch_idle_mm(void) > -{ > - struct mm_struct *mm = current->active_mm; > - > - if (mm == &init_mm) > - return; > - > - atomic_inc(&init_mm.mm_count); > - switch_mm(mm, &init_mm, current); > - current->active_mm = &init_mm; > - mmdrop(mm); > -} > - > -static void pre_suspend(void) > -{ > - HYPERVISOR_shared_info = (shared_info_t *)empty_zero_page; > - clear_fixmap(FIX_SHARED_INFO); > - > - xen_start_info->store_mfn = mfn_to_pfn(xen_start_info->store_mfn); > - xen_start_info->console.domU.mfn = > - mfn_to_pfn(xen_start_info->console.domU.mfn); > -} > - > -static void post_suspend(void) > -{ > - int i, j, k, fpp; > - extern unsigned long max_pfn; > - extern unsigned long *pfn_to_mfn_frame_list_list; > - extern unsigned long *pfn_to_mfn_frame_list[]; > - > - set_fixmap(FIX_SHARED_INFO, xen_start_info->shared_info); > - > - HYPERVISOR_shared_info = (shared_info_t *)fix_to_virt(FIX_SHARED_INFO); > - > - memset(empty_zero_page, 0, PAGE_SIZE); > - > - HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list = > - virt_to_mfn(pfn_to_mfn_frame_list_list); > - > - fpp = PAGE_SIZE/sizeof(unsigned long); > - for (i = 0, j = 0, k = -1; i < max_pfn; i += fpp, j++) { > - if ((j % fpp) == 0) { > - k++; > - pfn_to_mfn_frame_list_list[k] = > - virt_to_mfn(pfn_to_mfn_frame_list[k]); > - j = 0; > - } > - pfn_to_mfn_frame_list[k][j] = > - virt_to_mfn(&phys_to_machine_mapping[i]); > - } > - HYPERVISOR_shared_info->arch.max_pfn = max_pfn; > -} > - > -#else /* !(defined(__i386__) || defined(__x86_64__)) */ > - > -#define switch_idle_mm() ((void)0) > -#define mm_pin_all() ((void)0) > -#define pre_suspend() ((void)0) > -#define post_suspend() ((void)0) > - > -#endif > - > -static int __do_suspend(void *ignore) > -{ > - int err; > - > - extern void time_resume(void); > - > - BUG_ON(smp_processor_id() != 0); > - BUG_ON(in_interrupt()); > - > -#if defined(__i386__) || defined(__x86_64__) > - if (xen_feature(XENFEAT_auto_translated_physmap)) { > - printk(KERN_WARNING "Cannot suspend in " > - "auto_translated_physmap mode.\n"); > - return -EOPNOTSUPP; > - } > -#endif > - > - err = smp_suspend(); > - if (err) > - return err; > - > - xenbus_suspend(); > - > - preempt_disable(); > - > - mm_pin_all(); > - local_irq_disable(); > - preempt_enable(); > - > - gnttab_suspend(); > - > - pre_suspend(); > - > - /* > - * We'll stop somewhere inside this hypercall. When it returns, > - * we'll start resuming after the restore. > - */ > - HYPERVISOR_suspend(virt_to_mfn(xen_start_info)); > - > - shutting_down = SHUTDOWN_INVALID; > - > - post_suspend(); > - > - gnttab_resume(); > - > - irq_resume(); > - > - time_resume(); > - > - switch_idle_mm(); > - > - local_irq_enable(); > - > - xencons_resume(); > - > - xenbus_resume(); > - > - smp_resume(); > - > - return err; > -} > > static int shutdown_process(void *__unused) > { > @@ -222,11 +26,13 @@ static int shutdown_process(void *__unus > > if ((shutting_down == SHUTDOWN_POWEROFF) || > (shutting_down == SHUTDOWN_HALT)) { > - if (execve("/sbin/poweroff", poweroff_argv, envp) < 0) { > + if (call_usermodehelper_keys("/sbin/poweroff", poweroff_argv, envp, NULL, 0) < 0) { > +#ifdef CONFIG_XEN > sys_reboot(LINUX_REBOOT_MAGIC1, > LINUX_REBOOT_MAGIC2, > LINUX_REBOOT_CMD_POWER_OFF, > NULL); > +#endif /* CONFIG_XEN */ > } > } > > @@ -235,29 +41,21 @@ static int shutdown_process(void *__unus > return 0; > } > > -static int kthread_create_on_cpu(int (*f)(void *arg), > - void *arg, > - const char *name, > - int cpu) > -{ > - struct task_struct *p; > - p = kthread_create(f, arg, name); > - if (IS_ERR(p)) > - return PTR_ERR(p); > - kthread_bind(p, cpu); > - wake_up_process(p); > - return 0; > -} > > static void __shutdown_handler(void *unused) > { > int err; > > +#ifdef CONFIG_XEN > if (shutting_down != SHUTDOWN_SUSPEND) > err = kernel_thread(shutdown_process, NULL, > CLONE_FS | CLONE_FILES); > else > err = kthread_create_on_cpu(__do_suspend, NULL, "suspend", 0); > +#else /* !CONFIG_XEN */ > + err = kernel_thread(shutdown_process, NULL, > + CLONE_FS | CLONE_FILES); > +#endif /* !CONFIG_XEN */ > > if (err < 0) { > printk(KERN_WARNING "Error creating shutdown process (%d): " > @@ -272,6 +70,8 @@ static void shutdown_handler(struct xenb > char *str; > struct xenbus_transaction xbt; > int err; > + > + int cad_pid = 1; > > if (shutting_down != SHUTDOWN_INVALID) > return; > @@ -298,7 +98,7 @@ static void shutdown_handler(struct xenb > if (strcmp(str, "poweroff") == 0) > shutting_down = SHUTDOWN_POWEROFF; > else if (strcmp(str, "reboot") == 0) > - ctrl_alt_del(); > + kill_proc(cad_pid, SIGINT, 1); > else if (strcmp(str, "suspend") == 0) > shutting_down = SHUTDOWN_SUSPEND; > else if (strcmp(str, "halt") == 0) > @@ -378,6 +178,9 @@ static int __init setup_shutdown_event(v > .notifier_call = setup_shutdown_watcher > }; > register_xenstore_notifier(&xenstore_notifier); > + > + xenbus_write(XBT_NIL, "control", "reboot_module", "installed"); > + > return 0; > } > > diff -r 38f9bd7a4ce6 tools/python/xen/xend/image.py > --- a/tools/python/xen/xend/image.py Tue Oct 03 11:39:22 2006 +0100 > +++ b/tools/python/xen/xend/image.py Mon Oct 16 18:52:49 2006 +0900 > @@ -281,6 +281,7 @@ class HVMImageHandler(ImageHandler): > log.debug("apic = %d", self.apic) > > self.register_shutdown_watch() > + self.register_reboot_module_watch() > > return xc.hvm_build(dom = self.vm.getDomid(), > image = self.kernel, > @@ -383,6 +384,7 @@ class HVMImageHandler(ImageHandler): > > def destroy(self): > self.unregister_shutdown_watch(); > + self.unregister_reboot_module_watch(); > import signal > if not self.pid: > return > @@ -425,6 +427,39 @@ class HVMImageHandler(ImageHandler): > vm.refreshShutdown(vm.info) > > return 1 # Keep watching > + > + def register_reboot_module_watch(self): > + """ add xen store watch on control/reboot_module """ > + self.rebootModuleWatch = xswatch(self.vm.dompath + "/control/reboot_module", \ > + self.hvm_reboot_module) > + log.debug("hvm reboot module watch registered") > + > + def unregister_reboot_module_watch(self): > + """Remove the watch on the control/reboot_module, if any. Nothrow > + guarantee.""" > + > + try: > + if self.rebootModuleWatch: > + self.rebootModuleWatch.unwatch() > + except: > + log.exception("Unwatching hvm reboot module watch failed.") > + self.rebootModuleWatch = None > + log.debug("hvm reboot module watch unregistered") > + > + def hvm_reboot_module(self, _): > + """ watch call back on node control/reboot_module, > + if node changed, this function will be called > + """ > + xd = xen.xend.XendDomain.instance() > + vm = xd.domain_lookup( self.vm.getDomid() ) > + > + reboot_module_status = vm.readDom('control/reboot_module') > + log.debug("hvm_reboot_module fired, module status=%s", reboot_module_status) > + if reboot_module_status == 'installed': > + self.unregister_shutdown_watch() > + > + return 1 # Keep watching > + > > class IA64_HVM_ImageHandler(HVMImageHandler): > > diff -r 38f9bd7a4ce6 unmodified_drivers/linux-2.6/Makefile > --- a/unmodified_drivers/linux-2.6/Makefile Tue Oct 03 11:39:22 2006 +0100 > +++ b/unmodified_drivers/linux-2.6/Makefile Mon Oct 16 18:52:49 2006 +0900 > @@ -4,3 +4,4 @@ obj-m += xenbus/ > obj-m += xenbus/ > obj-m += blkfront/ > obj-m += netfront/ > +obj-m += util/ > diff -r 38f9bd7a4ce6 unmodified_drivers/linux-2.6/mkbuildtree > --- a/unmodified_drivers/linux-2.6/mkbuildtree Tue Oct 03 11:39:22 2006 +0100 > +++ b/unmodified_drivers/linux-2.6/mkbuildtree Mon Oct 16 18:52:49 2006 +0900 > @@ -14,6 +14,7 @@ ln -sf ${XL}/drivers/xen/core/gnttab.c p > ln -sf ${XL}/drivers/xen/core/gnttab.c platform-pci > ln -sf ${XL}/drivers/xen/core/features.c platform-pci > ln -sf ${XL}/drivers/xen/core/xen_proc.c xenbus > +ln -sf ${XL}/drivers/xen/core/reboot.c util > > mkdir -p include > mkdir -p include/xen > diff -r 38f9bd7a4ce6 linux-2.6-xen-sparse/drivers/xen/core/machine_reboot.c > --- /dev/null Thu Jan 01 00:00:00 1970 +0000 > +++ b/linux-2.6-xen-sparse/drivers/xen/core/machine_reboot.c Mon Oct 16 21:55:32 2006 +0900 > @@ -0,0 +1,206 @@ > +#define __KERNEL_SYSCALLS__ > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#if defined(__i386__) || defined(__x86_64__) > + > +/* > + * Power off function, if any > + */ > +void (*pm_power_off)(void); > +EXPORT_SYMBOL(pm_power_off); > + > +void machine_emergency_restart(void) > +{ > + /* We really want to get pending console data out before we die. */ > + xencons_force_flush(); > + HYPERVISOR_shutdown(SHUTDOWN_reboot); > +} > + > +void machine_restart(char * __unused) > +{ > + machine_emergency_restart(); > +} > + > +void machine_halt(void) > +{ > + machine_power_off(); > +} > + > +void machine_power_off(void) > +{ > + /* We really want to get pending console data out before we die. */ > + xencons_force_flush(); > + if (pm_power_off) > + pm_power_off(); > + HYPERVISOR_shutdown(SHUTDOWN_poweroff); > +} > + > +int reboot_thru_bios = 0; /* for dmi_scan.c */ > +EXPORT_SYMBOL(machine_restart); > +EXPORT_SYMBOL(machine_halt); > +EXPORT_SYMBOL(machine_power_off); > + > +#endif /* defined(__i386__) || defined(__x86_64__) */ > + > +#if defined(__i386__) || defined(__x86_64__) > + > +/* Ensure we run on the idle task page tables so that we will > + switch page tables before running user space. This is needed > + on architectures with separate kernel and user page tables > + because the user page table pointer is not saved/restored. */ > +static void switch_idle_mm(void) > +{ > + struct mm_struct *mm = current->active_mm; > + > + if (mm == &init_mm) > + return; > + > + atomic_inc(&init_mm.mm_count); > + switch_mm(mm, &init_mm, current); > + current->active_mm = &init_mm; > + mmdrop(mm); > +} > + > +static void pre_suspend(void) > +{ > + HYPERVISOR_shared_info = (shared_info_t *)empty_zero_page; > + clear_fixmap(FIX_SHARED_INFO); > + > + xen_start_info->store_mfn = mfn_to_pfn(xen_start_info->store_mfn); > + xen_start_info->console.domU.mfn = > + mfn_to_pfn(xen_start_info->console.domU.mfn); > +} > + > +static void post_suspend(void) > +{ > + int i, j, k, fpp; > + extern unsigned long max_pfn; > + extern unsigned long *pfn_to_mfn_frame_list_list; > + extern unsigned long *pfn_to_mfn_frame_list[]; > + > + set_fixmap(FIX_SHARED_INFO, xen_start_info->shared_info); > + > + HYPERVISOR_shared_info = (shared_info_t *)fix_to_virt(FIX_SHARED_INFO); > + > + memset(empty_zero_page, 0, PAGE_SIZE); > + > + HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list = > + virt_to_mfn(pfn_to_mfn_frame_list_list); > + > + fpp = PAGE_SIZE/sizeof(unsigned long); > + for (i = 0, j = 0, k = -1; i < max_pfn; i += fpp, j++) { > + if ((j % fpp) == 0) { > + k++; > + pfn_to_mfn_frame_list_list[k] = > + virt_to_mfn(pfn_to_mfn_frame_list[k]); > + j = 0; > + } > + pfn_to_mfn_frame_list[k][j] = > + virt_to_mfn(&phys_to_machine_mapping[i]); > + } > + HYPERVISOR_shared_info->arch.max_pfn = max_pfn; > +} > + > +#else /* !(defined(__i386__) || defined(__x86_64__)) */ > + > +#define switch_idle_mm() ((void)0) > +#define mm_pin_all() ((void)0) > +#define pre_suspend() ((void)0) > +#define post_suspend() ((void)0) > + > +#endif > + > +int __do_suspend(void *ignore) > +{ > + int err; > + > + extern void time_resume(void); > + > + BUG_ON(smp_processor_id() != 0); > + BUG_ON(in_interrupt()); > + > +#if defined(__i386__) || defined(__x86_64__) > + if (xen_feature(XENFEAT_auto_translated_physmap)) { > + printk(KERN_WARNING "Cannot suspend in " > + "auto_translated_physmap mode.\n"); > + return -EOPNOTSUPP; > + } > +#endif > + > + err = smp_suspend(); > + if (err) > + return err; > + > + xenbus_suspend(); > + > + preempt_disable(); > + > + mm_pin_all(); > + local_irq_disable(); > + preempt_enable(); > + > + gnttab_suspend(); > + > + pre_suspend(); > + > + /* > + * We'll stop somewhere inside this hypercall. When it returns, > + * we'll start resuming after the restore. > + */ > + HYPERVISOR_suspend(virt_to_mfn(xen_start_info)); > + > + shutting_down = SHUTDOWN_INVALID; > + > + post_suspend(); > + > + gnttab_resume(); > + > + irq_resume(); > + > + time_resume(); > + > + switch_idle_mm(); > + > + local_irq_enable(); > + > + xencons_resume(); > + > + xenbus_resume(); > + > + smp_resume(); > + > + return err; > +} > + > +int kthread_create_on_cpu(int (*f)(void *arg), > + void *arg, > + const char *name, > + int cpu) > +{ > + struct task_struct *p; > + p = kthread_create(f, arg, name); > + if (IS_ERR(p)) > + return PTR_ERR(p); > + kthread_bind(p, cpu); > + wake_up_process(p); > + return 0; > +} > diff -r 38f9bd7a4ce6 linux-2.6-xen-sparse/include/xen/reboot.h > --- /dev/null Thu Jan 01 00:00:00 1970 +0000 > +++ b/linux-2.6-xen-sparse/include/xen/reboot.h Mon Oct 16 22:35:22 2006 +0900 > @@ -0,0 +1,19 @@ > +#define SHUTDOWN_INVALID -1 > +#define SHUTDOWN_POWEROFF 0 > +#define SHUTDOWN_SUSPEND 2 > +/* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only > + * report a crash, not be instructed to crash! > + * HALT is the same as POWEROFF, as far as we're concerned. The tools use > + * the distinction when we return the reason code to them. > + */ > +#define SHUTDOWN_HALT 4 > + > +/****************************************************************************** > + * Stop/pickle callback handling. > + */ > + > +/* Ignore multiple shutdown requests. */ > +static int shutting_down = SHUTDOWN_INVALID; > + > +int kthread_create_on_cpu(int (*f)(void *), void *, const char *, int); > +int __do_suspend(void *); > > > ------------------------------------------------------------------------ > > _______________________________________________ > Xen-devel mailing list > Xen-devel@lists.xensource.com > http://lists.xensource.com/xen-devel --------------090506020802090507080907 Content-Type: text/plain; name="reboot.patch" Content-Transfer-Encoding: base64 Content-Disposition: inline; filename="reboot.patch" ZGlmZiAtciA0YTMyMGQyNmZjMjQgbGludXgtMi42LXhlbi1zcGFyc2UvZHJpdmVycy94ZW4v Y29yZS9NYWtlZmlsZQotLS0gYS9saW51eC0yLjYteGVuLXNwYXJzZS9kcml2ZXJzL3hlbi9j b3JlL01ha2VmaWxlCVRodSBPY3QgMjYgMTY6NTY6MTYgMjAwNiArMDEwMAorKysgYi9saW51 eC0yLjYteGVuLXNwYXJzZS9kcml2ZXJzL3hlbi9jb3JlL01ha2VmaWxlCUZyaSBPY3QgMjcg MTc6MDI6MTkgMjAwNiArMDkwMApAQCAtOSw1ICs5LDUgQEAgb2JqLSQoQ09ORklHX0hPVFBM VUdfQ1BVKQkrPSBjcHVfaG90cGx1Zwogb2JqLSQoQ09ORklHX0hPVFBMVUdfQ1BVKQkrPSBj cHVfaG90cGx1Zy5vCiBvYmotJChDT05GSUdfWEVOX1NZU0ZTKQkJKz0geGVuX3N5c2ZzLm8K IG9iai0kKENPTkZJR19YRU5fU0tCVUZGKQkrPSBza2J1ZmYubwotb2JqLSQoQ09ORklHX1hF Tl9SRUJPT1QpCSs9IHJlYm9vdC5vCitvYmotJChDT05GSUdfWEVOX1JFQk9PVCkJKz0gcmVi b290Lm8gbWFjaGluZV9yZWJvb3Qubwogb2JqLSQoQ09ORklHX1hFTl9TTVBCT09UKQkrPSBz bXBib290Lm8KZGlmZiAtciA0YTMyMGQyNmZjMjQgbGludXgtMi42LXhlbi1zcGFyc2UvZHJp dmVycy94ZW4vY29yZS9yZWJvb3QuYwotLS0gYS9saW51eC0yLjYteGVuLXNwYXJzZS9kcml2 ZXJzL3hlbi9jb3JlL3JlYm9vdC5jCVRodSBPY3QgMjYgMTY6NTY6MTYgMjAwNiArMDEwMAor KysgYi9saW51eC0yLjYteGVuLXNwYXJzZS9kcml2ZXJzL3hlbi9jb3JlL3JlYm9vdC5jCUZy aSBPY3QgMjcgMTc6MDM6NDYgMjAwNiArMDkwMApAQCAtMSwyMTUgKzEsMTkgQEAKICNkZWZp bmUgX19LRVJORUxfU1lTQ0FMTFNfXwogI2luY2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4KICNp bmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KLSNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2luY2x1 ZGUgPGxpbnV4L3VuaXN0ZC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1 ZGUgPGxpbnV4L3JlYm9vdC5oPgogI2luY2x1ZGUgPGxpbnV4L3N5c3JxLmg+Ci0jaW5jbHVk ZSA8bGludXgvc3RyaW5naWZ5Lmg+Ci0jaW5jbHVkZSA8YXNtL2lycS5oPgotI2luY2x1ZGUg PGFzbS9tbXVfY29udGV4dC5oPgotI2luY2x1ZGUgPHhlbi9ldnRjaG4uaD4KICNpbmNsdWRl IDxhc20vaHlwZXJ2aXNvci5oPgotI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UvZG9tMF9vcHMu aD4KICNpbmNsdWRlIDx4ZW4veGVuYnVzLmg+Ci0jaW5jbHVkZSA8bGludXgvY3B1Lmg+CiAj aW5jbHVkZSA8bGludXgva3RocmVhZC5oPgotI2luY2x1ZGUgPHhlbi9nbnR0YWIuaD4KLSNp bmNsdWRlIDx4ZW4veGVuY29ucy5oPgotI2luY2x1ZGUgPHhlbi9jcHVfaG90cGx1Zy5oPgor I2luY2x1ZGUgPHhlbi9yZWJvb3QuaD4KIAotZXh0ZXJuIHZvaWQgY3RybF9hbHRfZGVsKHZv aWQpOworTU9EVUxFX0xJQ0VOU0UoIkR1YWwgQlNEL0dQTCIpOwogCi0jZGVmaW5lIFNIVVRE T1dOX0lOVkFMSUQgIC0xCi0jZGVmaW5lIFNIVVRET1dOX1BPV0VST0ZGICAwCi0jZGVmaW5l IFNIVVRET1dOX1NVU1BFTkQgICAyCi0vKiBDb2RlIDMgaXMgU0hVVERPV05fQ1JBU0gsIHdo aWNoIHdlIGRvbid0IHVzZSBiZWNhdXNlIHRoZSBkb21haW4gY2FuIG9ubHkKLSAqIHJlcG9y dCBhIGNyYXNoLCBub3QgYmUgaW5zdHJ1Y3RlZCB0byBjcmFzaCEKLSAqIEhBTFQgaXMgdGhl IHNhbWUgYXMgUE9XRVJPRkYsIGFzIGZhciBhcyB3ZSdyZSBjb25jZXJuZWQuICBUaGUgdG9v bHMgdXNlCi0gKiB0aGUgZGlzdGluY3Rpb24gd2hlbiB3ZSByZXR1cm4gdGhlIHJlYXNvbiBj b2RlIHRvIHRoZW0uCi0gKi8KLSNkZWZpbmUgU0hVVERPV05fSEFMVCAgICAgIDQKLQotI2lm IGRlZmluZWQoX19pMzg2X18pIHx8IGRlZmluZWQoX194ODZfNjRfXykKLQotLyoKLSAqIFBv d2VyIG9mZiBmdW5jdGlvbiwgaWYgYW55Ci0gKi8KLXZvaWQgKCpwbV9wb3dlcl9vZmYpKHZv aWQpOwotRVhQT1JUX1NZTUJPTChwbV9wb3dlcl9vZmYpOwotCi12b2lkIG1hY2hpbmVfZW1l cmdlbmN5X3Jlc3RhcnQodm9pZCkKLXsKLQkvKiBXZSByZWFsbHkgd2FudCB0byBnZXQgcGVu ZGluZyBjb25zb2xlIGRhdGEgb3V0IGJlZm9yZSB3ZSBkaWUuICovCi0JeGVuY29uc19mb3Jj ZV9mbHVzaCgpOwotCUhZUEVSVklTT1Jfc2h1dGRvd24oU0hVVERPV05fcmVib290KTsKLX0K LQotdm9pZCBtYWNoaW5lX3Jlc3RhcnQoY2hhciAqIF9fdW51c2VkKQotewotCW1hY2hpbmVf ZW1lcmdlbmN5X3Jlc3RhcnQoKTsKLX0KLQotdm9pZCBtYWNoaW5lX2hhbHQodm9pZCkKLXsK LQltYWNoaW5lX3Bvd2VyX29mZigpOwotfQotCi12b2lkIG1hY2hpbmVfcG93ZXJfb2ZmKHZv aWQpCi17Ci0JLyogV2UgcmVhbGx5IHdhbnQgdG8gZ2V0IHBlbmRpbmcgY29uc29sZSBkYXRh IG91dCBiZWZvcmUgd2UgZGllLiAqLwotCXhlbmNvbnNfZm9yY2VfZmx1c2goKTsKLQlpZiAo cG1fcG93ZXJfb2ZmKQotCQlwbV9wb3dlcl9vZmYoKTsKLQlIWVBFUlZJU09SX3NodXRkb3du KFNIVVRET1dOX3Bvd2Vyb2ZmKTsKLX0KLQotaW50IHJlYm9vdF90aHJ1X2Jpb3MgPSAwOwkv KiBmb3IgZG1pX3NjYW4uYyAqLwotRVhQT1JUX1NZTUJPTChtYWNoaW5lX3Jlc3RhcnQpOwot RVhQT1JUX1NZTUJPTChtYWNoaW5lX2hhbHQpOwotRVhQT1JUX1NZTUJPTChtYWNoaW5lX3Bv d2VyX29mZik7Ci0KLSNlbmRpZiAvKiBkZWZpbmVkKF9faTM4Nl9fKSB8fCBkZWZpbmVkKF9f eDg2XzY0X18pICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqIFN0b3AvcGlj a2xlIGNhbGxiYWNrIGhhbmRsaW5nLgotICovCi0KLS8qIElnbm9yZSBtdWx0aXBsZSBzaHV0 ZG93biByZXF1ZXN0cy4gKi8KLXN0YXRpYyBpbnQgc2h1dHRpbmdfZG93biA9IFNIVVRET1dO X0lOVkFMSUQ7CiBzdGF0aWMgdm9pZCBfX3NodXRkb3duX2hhbmRsZXIodm9pZCAqdW51c2Vk KTsKIHN0YXRpYyBERUNMQVJFX1dPUksoc2h1dGRvd25fd29yaywgX19zaHV0ZG93bl9oYW5k bGVyLCBOVUxMKTsKLQotI2lmIGRlZmluZWQoX19pMzg2X18pIHx8IGRlZmluZWQoX194ODZf NjRfXykKLQotLyogRW5zdXJlIHdlIHJ1biBvbiB0aGUgaWRsZSB0YXNrIHBhZ2UgdGFibGVz IHNvIHRoYXQgd2Ugd2lsbAotICAgc3dpdGNoIHBhZ2UgdGFibGVzIGJlZm9yZSBydW5uaW5n IHVzZXIgc3BhY2UuIFRoaXMgaXMgbmVlZGVkCi0gICBvbiBhcmNoaXRlY3R1cmVzIHdpdGgg c2VwYXJhdGUga2VybmVsIGFuZCB1c2VyIHBhZ2UgdGFibGVzCi0gICBiZWNhdXNlIHRoZSB1 c2VyIHBhZ2UgdGFibGUgcG9pbnRlciBpcyBub3Qgc2F2ZWQvcmVzdG9yZWQuICovCi1zdGF0 aWMgdm9pZCBzd2l0Y2hfaWRsZV9tbSh2b2lkKQotewotCXN0cnVjdCBtbV9zdHJ1Y3QgKm1t ID0gY3VycmVudC0+YWN0aXZlX21tOwotCi0JaWYgKG1tID09ICZpbml0X21tKQotCQlyZXR1 cm47Ci0KLQlhdG9taWNfaW5jKCZpbml0X21tLm1tX2NvdW50KTsKLQlzd2l0Y2hfbW0obW0s ICZpbml0X21tLCBjdXJyZW50KTsKLQljdXJyZW50LT5hY3RpdmVfbW0gPSAmaW5pdF9tbTsK LQltbWRyb3AobW0pOwotfQotCi1zdGF0aWMgdm9pZCBwcmVfc3VzcGVuZCh2b2lkKQotewot CUhZUEVSVklTT1Jfc2hhcmVkX2luZm8gPSAoc2hhcmVkX2luZm9fdCAqKWVtcHR5X3plcm9f cGFnZTsKLQljbGVhcl9maXhtYXAoRklYX1NIQVJFRF9JTkZPKTsKLQotCXhlbl9zdGFydF9p bmZvLT5zdG9yZV9tZm4gPSBtZm5fdG9fcGZuKHhlbl9zdGFydF9pbmZvLT5zdG9yZV9tZm4p OwotCXhlbl9zdGFydF9pbmZvLT5jb25zb2xlLmRvbVUubWZuID0KLQkJbWZuX3RvX3Bmbih4 ZW5fc3RhcnRfaW5mby0+Y29uc29sZS5kb21VLm1mbik7Ci19Ci0KLXN0YXRpYyB2b2lkIHBv c3Rfc3VzcGVuZCh2b2lkKQotewotCWludCBpLCBqLCBrLCBmcHA7Ci0JZXh0ZXJuIHVuc2ln bmVkIGxvbmcgbWF4X3BmbjsKLQlleHRlcm4gdW5zaWduZWQgbG9uZyAqcGZuX3RvX21mbl9m cmFtZV9saXN0X2xpc3Q7Ci0JZXh0ZXJuIHVuc2lnbmVkIGxvbmcgKnBmbl90b19tZm5fZnJh bWVfbGlzdFtdOwotCi0Jc2V0X2ZpeG1hcChGSVhfU0hBUkVEX0lORk8sIHhlbl9zdGFydF9p bmZvLT5zaGFyZWRfaW5mbyk7Ci0KLQlIWVBFUlZJU09SX3NoYXJlZF9pbmZvID0gKHNoYXJl ZF9pbmZvX3QgKilmaXhfdG9fdmlydChGSVhfU0hBUkVEX0lORk8pOwotCi0JbWVtc2V0KGVt cHR5X3plcm9fcGFnZSwgMCwgUEFHRV9TSVpFKTsKLQotCUhZUEVSVklTT1Jfc2hhcmVkX2lu Zm8tPmFyY2gucGZuX3RvX21mbl9mcmFtZV9saXN0X2xpc3QgPQotCQl2aXJ0X3RvX21mbihw Zm5fdG9fbWZuX2ZyYW1lX2xpc3RfbGlzdCk7Ci0KLQlmcHAgPSBQQUdFX1NJWkUvc2l6ZW9m KHVuc2lnbmVkIGxvbmcpOwotCWZvciAoaSA9IDAsIGogPSAwLCBrID0gLTE7IGkgPCBtYXhf cGZuOyBpICs9IGZwcCwgaisrKSB7Ci0JCWlmICgoaiAlIGZwcCkgPT0gMCkgewotCQkJaysr OwotCQkJcGZuX3RvX21mbl9mcmFtZV9saXN0X2xpc3Rba10gPQotCQkJCXZpcnRfdG9fbWZu KHBmbl90b19tZm5fZnJhbWVfbGlzdFtrXSk7Ci0JCQlqID0gMDsKLQkJfQotCQlwZm5fdG9f bWZuX2ZyYW1lX2xpc3Rba11bal0gPQotCQkJdmlydF90b19tZm4oJnBoeXNfdG9fbWFjaGlu ZV9tYXBwaW5nW2ldKTsKLQl9Ci0JSFlQRVJWSVNPUl9zaGFyZWRfaW5mby0+YXJjaC5tYXhf cGZuID0gbWF4X3BmbjsKLX0KLQotI2Vsc2UgLyogIShkZWZpbmVkKF9faTM4Nl9fKSB8fCBk ZWZpbmVkKF9feDg2XzY0X18pKSAqLwotCi0jZGVmaW5lIHN3aXRjaF9pZGxlX21tKCkJKCh2 b2lkKTApCi0jZGVmaW5lIG1tX3Bpbl9hbGwoKQkJKCh2b2lkKTApCi0jZGVmaW5lIHByZV9z dXNwZW5kKCkJCSgodm9pZCkwKQotI2RlZmluZSBwb3N0X3N1c3BlbmQoKQkJKCh2b2lkKTAp Ci0KLSNlbmRpZgotCi1zdGF0aWMgaW50IF9fZG9fc3VzcGVuZCh2b2lkICppZ25vcmUpCi17 Ci0JaW50IGVycjsKLQotCWV4dGVybiB2b2lkIHRpbWVfcmVzdW1lKHZvaWQpOwotCi0JQlVH X09OKHNtcF9wcm9jZXNzb3JfaWQoKSAhPSAwKTsKLQlCVUdfT04oaW5faW50ZXJydXB0KCkp OwotCi0jaWYgZGVmaW5lZChfX2kzODZfXykgfHwgZGVmaW5lZChfX3g4Nl82NF9fKQotCWlm ICh4ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9waHlzbWFwKSkgewotCQlw cmludGsoS0VSTl9XQVJOSU5HICJDYW5ub3Qgc3VzcGVuZCBpbiAiCi0JCSAgICAgICAiYXV0 b190cmFuc2xhdGVkX3BoeXNtYXAgbW9kZS5cbiIpOwotCQlyZXR1cm4gLUVPUE5PVFNVUFA7 Ci0JfQotI2VuZGlmCi0KLQllcnIgPSBzbXBfc3VzcGVuZCgpOwotCWlmIChlcnIpCi0JCXJl dHVybiBlcnI7Ci0KLQl4ZW5idXNfc3VzcGVuZCgpOwotCi0JcHJlZW1wdF9kaXNhYmxlKCk7 Ci0KLQltbV9waW5fYWxsKCk7Ci0JbG9jYWxfaXJxX2Rpc2FibGUoKTsKLQlwcmVlbXB0X2Vu YWJsZSgpOwotCi0JZ250dGFiX3N1c3BlbmQoKTsKLQotCXByZV9zdXNwZW5kKCk7Ci0KLQkv KgotCSAqIFdlJ2xsIHN0b3Agc29tZXdoZXJlIGluc2lkZSB0aGlzIGh5cGVyY2FsbC4gV2hl biBpdCByZXR1cm5zLAotCSAqIHdlJ2xsIHN0YXJ0IHJlc3VtaW5nIGFmdGVyIHRoZSByZXN0 b3JlLgotCSAqLwotCUhZUEVSVklTT1Jfc3VzcGVuZCh2aXJ0X3RvX21mbih4ZW5fc3RhcnRf aW5mbykpOwotCi0Jc2h1dHRpbmdfZG93biA9IFNIVVRET1dOX0lOVkFMSUQ7Ci0KLQlwb3N0 X3N1c3BlbmQoKTsKLQotCWdudHRhYl9yZXN1bWUoKTsKLQotCWlycV9yZXN1bWUoKTsKLQot CXRpbWVfcmVzdW1lKCk7Ci0KLQlzd2l0Y2hfaWRsZV9tbSgpOwotCi0JbG9jYWxfaXJxX2Vu YWJsZSgpOwotCi0JeGVuY29uc19yZXN1bWUoKTsKLQotCXhlbmJ1c19yZXN1bWUoKTsKLQot CXNtcF9yZXN1bWUoKTsKLQotCXJldHVybiBlcnI7Ci19CiAKIHN0YXRpYyBpbnQgc2h1dGRv d25fcHJvY2Vzcyh2b2lkICpfX3VudXNlZCkKIHsKQEAgLTIyMiwxMSArMjYsMTMgQEAgc3Rh dGljIGludCBzaHV0ZG93bl9wcm9jZXNzKHZvaWQgKl9fdW51cwogCiAJaWYgKChzaHV0dGlu Z19kb3duID09IFNIVVRET1dOX1BPV0VST0ZGKSB8fAogCSAgICAoc2h1dHRpbmdfZG93biA9 PSBTSFVURE9XTl9IQUxUKSkgewotCQlpZiAoZXhlY3ZlKCIvc2Jpbi9wb3dlcm9mZiIsIHBv d2Vyb2ZmX2FyZ3YsIGVudnApIDwgMCkgeworCQlpZiAoY2FsbF91c2VybW9kZWhlbHBlcl9r ZXlzKCIvc2Jpbi9wb3dlcm9mZiIsIHBvd2Vyb2ZmX2FyZ3YsIGVudnAsIE5VTEwsIDApIDwg MCkgeworI2lmZGVmIENPTkZJR19YRU4KIAkJCXN5c19yZWJvb3QoTElOVVhfUkVCT09UX01B R0lDMSwKIAkJCQkgICBMSU5VWF9SRUJPT1RfTUFHSUMyLAogCQkJCSAgIExJTlVYX1JFQk9P VF9DTURfUE9XRVJfT0ZGLAogCQkJCSAgIE5VTEwpOworI2VuZGlmIC8qIENPTkZJR19YRU4g Ki8KIAkJfQogCX0KIApAQCAtMjM1LDI5ICs0MSwyMSBAQCBzdGF0aWMgaW50IHNodXRkb3du X3Byb2Nlc3Modm9pZCAqX191bnVzCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQga3Ro cmVhZF9jcmVhdGVfb25fY3B1KGludCAoKmYpKHZvaWQgKmFyZyksCi0JCQkJIHZvaWQgKmFy ZywKLQkJCQkgY29uc3QgY2hhciAqbmFtZSwKLQkJCQkgaW50IGNwdSkKLXsKLQlzdHJ1Y3Qg dGFza19zdHJ1Y3QgKnA7Ci0JcCA9IGt0aHJlYWRfY3JlYXRlKGYsIGFyZywgbmFtZSk7Ci0J aWYgKElTX0VSUihwKSkKLQkJcmV0dXJuIFBUUl9FUlIocCk7Ci0Ja3RocmVhZF9iaW5kKHAs IGNwdSk7Ci0Jd2FrZV91cF9wcm9jZXNzKHApOwotCXJldHVybiAwOwotfQogCiBzdGF0aWMg dm9pZCBfX3NodXRkb3duX2hhbmRsZXIodm9pZCAqdW51c2VkKQogewogCWludCBlcnI7CiAK KyNpZmRlZiBDT05GSUdfWEVOCiAJaWYgKHNodXR0aW5nX2Rvd24gIT0gU0hVVERPV05fU1VT UEVORCkKIAkJZXJyID0ga2VybmVsX3RocmVhZChzaHV0ZG93bl9wcm9jZXNzLCBOVUxMLAog CQkJCSAgICBDTE9ORV9GUyB8IENMT05FX0ZJTEVTKTsKIAllbHNlCiAJCWVyciA9IGt0aHJl YWRfY3JlYXRlX29uX2NwdShfX2RvX3N1c3BlbmQsIE5VTEwsICJzdXNwZW5kIiwgMCk7Cisj ZWxzZSAvKiAhQ09ORklHX1hFTiAqLworCQllcnIgPSBrZXJuZWxfdGhyZWFkKHNodXRkb3du X3Byb2Nlc3MsIE5VTEwsCisJCQkJICAgIENMT05FX0ZTIHwgQ0xPTkVfRklMRVMpOworI2Vu ZGlmIC8qICFDT05GSUdfWEVOICovCiAKIAlpZiAoZXJyIDwgMCkgewogCQlwcmludGsoS0VS Tl9XQVJOSU5HICJFcnJvciBjcmVhdGluZyBzaHV0ZG93biBwcm9jZXNzICglZCk6ICIKQEAg LTI3Miw2ICs3MCw4IEBAIHN0YXRpYyB2b2lkIHNodXRkb3duX2hhbmRsZXIoc3RydWN0IHhl bmIKIAljaGFyICpzdHI7CiAJc3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQ7CiAJaW50 IGVycjsKKworCWludCBjYWRfcGlkID0gMTsgCiAKIAlpZiAoc2h1dHRpbmdfZG93biAhPSBT SFVURE9XTl9JTlZBTElEKQogCQlyZXR1cm47CkBAIC0yOTgsNyArOTgsNyBAQCBzdGF0aWMg dm9pZCBzaHV0ZG93bl9oYW5kbGVyKHN0cnVjdCB4ZW5iCiAJaWYgKHN0cmNtcChzdHIsICJw b3dlcm9mZiIpID09IDApCiAJCXNodXR0aW5nX2Rvd24gPSBTSFVURE9XTl9QT1dFUk9GRjsK IAllbHNlIGlmIChzdHJjbXAoc3RyLCAicmVib290IikgPT0gMCkKLQkJY3RybF9hbHRfZGVs KCk7CisJCWtpbGxfcHJvYyhjYWRfcGlkLCBTSUdJTlQsIDEpOwogCWVsc2UgaWYgKHN0cmNt cChzdHIsICJzdXNwZW5kIikgPT0gMCkKIAkJc2h1dHRpbmdfZG93biA9IFNIVVRET1dOX1NV U1BFTkQ7CiAJZWxzZSBpZiAoc3RyY21wKHN0ciwgImhhbHQiKSA9PSAwKQpAQCAtMzc4LDYg KzE3OCwxMSBAQCBzdGF0aWMgaW50IF9faW5pdCBzZXR1cF9zaHV0ZG93bl9ldmVudCh2CiAJ CS5ub3RpZmllcl9jYWxsID0gc2V0dXBfc2h1dGRvd25fd2F0Y2hlcgogCX07CiAJcmVnaXN0 ZXJfeGVuc3RvcmVfbm90aWZpZXIoJnhlbnN0b3JlX25vdGlmaWVyKTsKKworCWlmICghaXNf aW5pdGlhbF94ZW5kb21haW4oKSkgeworCQl4ZW5idXNfd3JpdGUoWEJUX05JTCwgImNvbnRy b2wiLCAicmVib290X21vZHVsZSIsICJpbnN0YWxsZWQiKTsKKwl9CisKIAlyZXR1cm4gMDsK IH0KIApkaWZmIC1yIDRhMzIwZDI2ZmMyNCB0b29scy9weXRob24veGVuL3hlbmQvaW1hZ2Uu cHkKLS0tIGEvdG9vbHMvcHl0aG9uL3hlbi94ZW5kL2ltYWdlLnB5CVRodSBPY3QgMjYgMTY6 NTY6MTYgMjAwNiArMDEwMAorKysgYi90b29scy9weXRob24veGVuL3hlbmQvaW1hZ2UucHkJ RnJpIE9jdCAyNyAxNzowMjoxOSAyMDA2ICswOTAwCkBAIC0yODIsNiArMjgyLDcgQEAgY2xh c3MgSFZNSW1hZ2VIYW5kbGVyKEltYWdlSGFuZGxlcik6CiAgICAgICAgIGxvZy5kZWJ1Zygi YXBpYyAgICAgICAgICAgPSAlZCIsIHNlbGYuYXBpYykKIAogICAgICAgICBzZWxmLnJlZ2lz dGVyX3NodXRkb3duX3dhdGNoKCkKKyAgICAgICAgc2VsZi5yZWdpc3Rlcl9yZWJvb3RfbW9k dWxlX3dhdGNoKCkKIAogICAgICAgICByZXR1cm4geGMuaHZtX2J1aWxkKGRvbSAgICAgICAg ICAgID0gc2VsZi52bS5nZXREb21pZCgpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAg IGltYWdlICAgICAgICAgID0gc2VsZi5rZXJuZWwsCkBAIC00MjIsNiArNDIzLDcgQEAgY2xh c3MgSFZNSW1hZ2VIYW5kbGVyKEltYWdlSGFuZGxlcik6CiAKICAgICBkZWYgZGVzdHJveShz ZWxmKToKICAgICAgICAgc2VsZi51bnJlZ2lzdGVyX3NodXRkb3duX3dhdGNoKCk7CisgICAg ICAgIHNlbGYudW5yZWdpc3Rlcl9yZWJvb3RfbW9kdWxlX3dhdGNoKCk7CiAgICAgICAgIGlm IG5vdCBzZWxmLnBpZDoKICAgICAgICAgICAgIHJldHVybgogICAgICAgICBvcy5raWxsKHNl bGYucGlkLCBzaWduYWwuU0lHS0lMTCkKQEAgLTQ2Myw2ICs0NjUsMzkgQEAgY2xhc3MgSFZN SW1hZ2VIYW5kbGVyKEltYWdlSGFuZGxlcik6CiAgICAgICAgICAgICAgICAgdm0ucmVmcmVz aFNodXRkb3duKHZtLmluZm8pCiAKICAgICAgICAgcmV0dXJuIDEgIyBLZWVwIHdhdGNoaW5n CisKKyAgICBkZWYgcmVnaXN0ZXJfcmVib290X21vZHVsZV93YXRjaChzZWxmKToKKyAgICAg ICAgIiIiIGFkZCB4ZW4gc3RvcmUgd2F0Y2ggb24gY29udHJvbC9yZWJvb3RfbW9kdWxlICIi IgorICAgICAgICBzZWxmLnJlYm9vdE1vZHVsZVdhdGNoID0geHN3YXRjaChzZWxmLnZtLmRv bXBhdGggKyAiL2NvbnRyb2wvcmVib290X21vZHVsZSIsIFwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHNlbGYuaHZtX3JlYm9vdF9tb2R1bGUpCisgICAgICAgIGxv Zy5kZWJ1ZygiaHZtIHJlYm9vdCBtb2R1bGUgd2F0Y2ggcmVnaXN0ZXJlZCIpCisKKyAgICBk ZWYgdW5yZWdpc3Rlcl9yZWJvb3RfbW9kdWxlX3dhdGNoKHNlbGYpOgorICAgICAgICAiIiJS ZW1vdmUgdGhlIHdhdGNoIG9uIHRoZSBjb250cm9sL3JlYm9vdF9tb2R1bGUsIGlmIGFueS4g Tm90aHJvdworICAgICAgICBndWFyYW50ZWUuIiIiCisKKyAgICAgICAgdHJ5OgorICAgICAg ICAgICAgaWYgc2VsZi5yZWJvb3RNb2R1bGVXYXRjaDoKKyAgICAgICAgICAgICAgICBzZWxm LnJlYm9vdE1vZHVsZVdhdGNoLnVud2F0Y2goKQorICAgICAgICBleGNlcHQ6CisgICAgICAg ICAgICBsb2cuZXhjZXB0aW9uKCJVbndhdGNoaW5nIGh2bSByZWJvb3QgbW9kdWxlIHdhdGNo IGZhaWxlZC4iKQorICAgICAgICBzZWxmLnJlYm9vdE1vZHVsZVdhdGNoID0gTm9uZQorICAg ICAgICBsb2cuZGVidWcoImh2bSByZWJvb3QgbW9kdWxlIHdhdGNoIHVucmVnaXN0ZXJlZCIp CisKKyAgICBkZWYgaHZtX3JlYm9vdF9tb2R1bGUoc2VsZiwgXyk6CisgICAgICAgICIiIiB3 YXRjaCBjYWxsIGJhY2sgb24gbm9kZSBjb250cm9sL3JlYm9vdF9tb2R1bGUsCisgICAgICAg ICAgICBpZiBub2RlIGNoYW5nZWQsIHRoaXMgZnVuY3Rpb24gd2lsbCBiZSBjYWxsZWQKKyAg ICAgICAgIiIiCisgICAgICAgIHhkID0geGVuLnhlbmQuWGVuZERvbWFpbi5pbnN0YW5jZSgp CisgICAgICAgIHZtID0geGQuZG9tYWluX2xvb2t1cCggc2VsZi52bS5nZXREb21pZCgpICkK KworICAgICAgICByZWJvb3RfbW9kdWxlX3N0YXR1cyA9IHZtLnJlYWREb20oJ2NvbnRyb2wv cmVib290X21vZHVsZScpCisgICAgICAgIGxvZy5kZWJ1ZygiaHZtX3JlYm9vdF9tb2R1bGUg ZmlyZWQsIG1vZHVsZSBzdGF0dXM9JXMiLCByZWJvb3RfbW9kdWxlX3N0YXR1cykKKyAgICAg ICAgaWYgcmVib290X21vZHVsZV9zdGF0dXMgPT0gJ2luc3RhbGxlZCc6CisgICAgICAgICAg ICBzZWxmLnVucmVnaXN0ZXJfc2h1dGRvd25fd2F0Y2goKQorCisgICAgICAgIHJldHVybiAx ICMgS2VlcCB3YXRjaGluZworCiAKIGNsYXNzIElBNjRfSFZNX0ltYWdlSGFuZGxlcihIVk1J bWFnZUhhbmRsZXIpOgogCmRpZmYgLXIgNGEzMjBkMjZmYzI0IHVubW9kaWZpZWRfZHJpdmVy cy9saW51eC0yLjYvTWFrZWZpbGUKLS0tIGEvdW5tb2RpZmllZF9kcml2ZXJzL2xpbnV4LTIu Ni9NYWtlZmlsZQlUaHUgT2N0IDI2IDE2OjU2OjE2IDIwMDYgKzAxMDAKKysrIGIvdW5tb2Rp ZmllZF9kcml2ZXJzL2xpbnV4LTIuNi9NYWtlZmlsZQlGcmkgT2N0IDI3IDE3OjAyOjE5IDIw MDYgKzA5MDAKQEAgLTQsMyArNCw0IEBAIG9iai1tICs9IHhlbmJ1cy8KIG9iai1tICs9IHhl bmJ1cy8KIG9iai1tICs9IGJsa2Zyb250Lwogb2JqLW0gKz0gbmV0ZnJvbnQvCitvYmotbSAr PSB1dGlsLwpkaWZmIC1yIDRhMzIwZDI2ZmMyNCB1bm1vZGlmaWVkX2RyaXZlcnMvbGludXgt Mi42L21rYnVpbGR0cmVlCi0tLSBhL3VubW9kaWZpZWRfZHJpdmVycy9saW51eC0yLjYvbWti dWlsZHRyZWUJVGh1IE9jdCAyNiAxNjo1NjoxNiAyMDA2ICswMTAwCisrKyBiL3VubW9kaWZp ZWRfZHJpdmVycy9saW51eC0yLjYvbWtidWlsZHRyZWUJRnJpIE9jdCAyNyAxNzowMjoxOSAy MDA2ICswOTAwCkBAIC0yMiw2ICsyMiw3IEBAIGxuIC1zZiAke1hMfS9kcml2ZXJzL3hlbi9j b3JlL2dudHRhYi5jIHAKIGxuIC1zZiAke1hMfS9kcml2ZXJzL3hlbi9jb3JlL2dudHRhYi5j IHBsYXRmb3JtLXBjaQogbG4gLXNmICR7WEx9L2RyaXZlcnMveGVuL2NvcmUvZmVhdHVyZXMu YyBwbGF0Zm9ybS1wY2kKIGxuIC1zZiAke1hMfS9kcml2ZXJzL3hlbi9jb3JlL3hlbl9wcm9j LmMgeGVuYnVzCitsbiAtc2YgJHtYTH0vZHJpdmVycy94ZW4vY29yZS9yZWJvb3QuYyB1dGls CiAKIG1rZGlyIC1wIGluY2x1ZGUKIG1rZGlyIC1wIGluY2x1ZGUveGVuCmRpZmYgLXIgNGEz MjBkMjZmYzI0IGxpbnV4LTIuNi14ZW4tc3BhcnNlL2RyaXZlcnMveGVuL2NvcmUvbWFjaGlu ZV9yZWJvb3QuYwotLS0gL2Rldi9udWxsCVRodSBKYW4gMDEgMDA6MDA6MDAgMTk3MCArMDAw MAorKysgYi9saW51eC0yLjYteGVuLXNwYXJzZS9kcml2ZXJzL3hlbi9jb3JlL21hY2hpbmVf cmVib290LmMJRnJpIE9jdCAyNyAxNzowMjoxOSAyMDA2ICswOTAwCkBAIC0wLDAgKzEsMjA2 IEBACisjZGVmaW5lIF9fS0VSTkVMX1NZU0NBTExTX18KKyNpbmNsdWRlIDxsaW51eC92ZXJz aW9uLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW0u aD4KKyNpbmNsdWRlIDxsaW51eC91bmlzdGQuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUu aD4KKyNpbmNsdWRlIDxsaW51eC9yZWJvb3QuaD4KKyNpbmNsdWRlIDxsaW51eC9zeXNycS5o PgorI2luY2x1ZGUgPGxpbnV4L3N0cmluZ2lmeS5oPgorI2luY2x1ZGUgPGFzbS9pcnEuaD4K KyNpbmNsdWRlIDxhc20vbW11X2NvbnRleHQuaD4KKyNpbmNsdWRlIDx4ZW4vZXZ0Y2huLmg+ CisjaW5jbHVkZSA8YXNtL2h5cGVydmlzb3IuaD4KKyNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNl L2RvbTBfb3BzLmg+CisjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgorI2luY2x1ZGUgPGxpbnV4 L2NwdS5oPgorI2luY2x1ZGUgPGxpbnV4L2t0aHJlYWQuaD4KKyNpbmNsdWRlIDx4ZW4vZ250 dGFiLmg+CisjaW5jbHVkZSA8eGVuL3hlbmNvbnMuaD4KKyNpbmNsdWRlIDx4ZW4vY3B1X2hv dHBsdWcuaD4KKyNpbmNsdWRlIDx4ZW4vcmVib290Lmg+CisKKyNpZiBkZWZpbmVkKF9faTM4 Nl9fKSB8fCBkZWZpbmVkKF9feDg2XzY0X18pCisKKy8qCisgKiBQb3dlciBvZmYgZnVuY3Rp b24sIGlmIGFueQorICovCit2b2lkICgqcG1fcG93ZXJfb2ZmKSh2b2lkKTsKK0VYUE9SVF9T WU1CT0wocG1fcG93ZXJfb2ZmKTsKKwordm9pZCBtYWNoaW5lX2VtZXJnZW5jeV9yZXN0YXJ0 KHZvaWQpCit7CisJLyogV2UgcmVhbGx5IHdhbnQgdG8gZ2V0IHBlbmRpbmcgY29uc29sZSBk YXRhIG91dCBiZWZvcmUgd2UgZGllLiAqLworCXhlbmNvbnNfZm9yY2VfZmx1c2goKTsKKwlI WVBFUlZJU09SX3NodXRkb3duKFNIVVRET1dOX3JlYm9vdCk7Cit9CisKK3ZvaWQgbWFjaGlu ZV9yZXN0YXJ0KGNoYXIgKiBfX3VudXNlZCkKK3sKKwltYWNoaW5lX2VtZXJnZW5jeV9yZXN0 YXJ0KCk7Cit9CisKK3ZvaWQgbWFjaGluZV9oYWx0KHZvaWQpCit7CisJbWFjaGluZV9wb3dl cl9vZmYoKTsKK30KKwordm9pZCBtYWNoaW5lX3Bvd2VyX29mZih2b2lkKQoreworCS8qIFdl IHJlYWxseSB3YW50IHRvIGdldCBwZW5kaW5nIGNvbnNvbGUgZGF0YSBvdXQgYmVmb3JlIHdl IGRpZS4gKi8KKwl4ZW5jb25zX2ZvcmNlX2ZsdXNoKCk7CisJaWYgKHBtX3Bvd2VyX29mZikK KwkJcG1fcG93ZXJfb2ZmKCk7CisJSFlQRVJWSVNPUl9zaHV0ZG93bihTSFVURE9XTl9wb3dl cm9mZik7Cit9CisKK2ludCByZWJvb3RfdGhydV9iaW9zID0gMDsJLyogZm9yIGRtaV9zY2Fu LmMgKi8KK0VYUE9SVF9TWU1CT0wobWFjaGluZV9yZXN0YXJ0KTsKK0VYUE9SVF9TWU1CT0wo bWFjaGluZV9oYWx0KTsKK0VYUE9SVF9TWU1CT0wobWFjaGluZV9wb3dlcl9vZmYpOworCisj ZW5kaWYgLyogZGVmaW5lZChfX2kzODZfXykgfHwgZGVmaW5lZChfX3g4Nl82NF9fKSAqLwor CisjaWYgZGVmaW5lZChfX2kzODZfXykgfHwgZGVmaW5lZChfX3g4Nl82NF9fKQorCisvKiBF bnN1cmUgd2UgcnVuIG9uIHRoZSBpZGxlIHRhc2sgcGFnZSB0YWJsZXMgc28gdGhhdCB3ZSB3 aWxsCisgICBzd2l0Y2ggcGFnZSB0YWJsZXMgYmVmb3JlIHJ1bm5pbmcgdXNlciBzcGFjZS4g VGhpcyBpcyBuZWVkZWQKKyAgIG9uIGFyY2hpdGVjdHVyZXMgd2l0aCBzZXBhcmF0ZSBrZXJu ZWwgYW5kIHVzZXIgcGFnZSB0YWJsZXMKKyAgIGJlY2F1c2UgdGhlIHVzZXIgcGFnZSB0YWJs ZSBwb2ludGVyIGlzIG5vdCBzYXZlZC9yZXN0b3JlZC4gKi8KK3N0YXRpYyB2b2lkIHN3aXRj aF9pZGxlX21tKHZvaWQpCit7CisJc3RydWN0IG1tX3N0cnVjdCAqbW0gPSBjdXJyZW50LT5h Y3RpdmVfbW07CisKKwlpZiAobW0gPT0gJmluaXRfbW0pCisJCXJldHVybjsKKworCWF0b21p Y19pbmMoJmluaXRfbW0ubW1fY291bnQpOworCXN3aXRjaF9tbShtbSwgJmluaXRfbW0sIGN1 cnJlbnQpOworCWN1cnJlbnQtPmFjdGl2ZV9tbSA9ICZpbml0X21tOworCW1tZHJvcChtbSk7 Cit9CisKK3N0YXRpYyB2b2lkIHByZV9zdXNwZW5kKHZvaWQpCit7CisJSFlQRVJWSVNPUl9z aGFyZWRfaW5mbyA9IChzaGFyZWRfaW5mb190ICopZW1wdHlfemVyb19wYWdlOworCWNsZWFy X2ZpeG1hcChGSVhfU0hBUkVEX0lORk8pOworCisJeGVuX3N0YXJ0X2luZm8tPnN0b3JlX21m biA9IG1mbl90b19wZm4oeGVuX3N0YXJ0X2luZm8tPnN0b3JlX21mbik7CisJeGVuX3N0YXJ0 X2luZm8tPmNvbnNvbGUuZG9tVS5tZm4gPQorCQltZm5fdG9fcGZuKHhlbl9zdGFydF9pbmZv LT5jb25zb2xlLmRvbVUubWZuKTsKK30KKworc3RhdGljIHZvaWQgcG9zdF9zdXNwZW5kKHZv aWQpCit7CisJaW50IGksIGosIGssIGZwcDsKKwlleHRlcm4gdW5zaWduZWQgbG9uZyBtYXhf cGZuOworCWV4dGVybiB1bnNpZ25lZCBsb25nICpwZm5fdG9fbWZuX2ZyYW1lX2xpc3RfbGlz dDsKKwlleHRlcm4gdW5zaWduZWQgbG9uZyAqcGZuX3RvX21mbl9mcmFtZV9saXN0W107CisK KwlzZXRfZml4bWFwKEZJWF9TSEFSRURfSU5GTywgeGVuX3N0YXJ0X2luZm8tPnNoYXJlZF9p bmZvKTsKKworCUhZUEVSVklTT1Jfc2hhcmVkX2luZm8gPSAoc2hhcmVkX2luZm9fdCAqKWZp eF90b192aXJ0KEZJWF9TSEFSRURfSU5GTyk7CisKKwltZW1zZXQoZW1wdHlfemVyb19wYWdl LCAwLCBQQUdFX1NJWkUpOworCisJSFlQRVJWSVNPUl9zaGFyZWRfaW5mby0+YXJjaC5wZm5f dG9fbWZuX2ZyYW1lX2xpc3RfbGlzdCA9CisJCXZpcnRfdG9fbWZuKHBmbl90b19tZm5fZnJh bWVfbGlzdF9saXN0KTsKKworCWZwcCA9IFBBR0VfU0laRS9zaXplb2YodW5zaWduZWQgbG9u Zyk7CisJZm9yIChpID0gMCwgaiA9IDAsIGsgPSAtMTsgaSA8IG1heF9wZm47IGkgKz0gZnBw LCBqKyspIHsKKwkJaWYgKChqICUgZnBwKSA9PSAwKSB7CisJCQlrKys7CisJCQlwZm5fdG9f bWZuX2ZyYW1lX2xpc3RfbGlzdFtrXSA9CisJCQkJdmlydF90b19tZm4ocGZuX3RvX21mbl9m cmFtZV9saXN0W2tdKTsKKwkJCWogPSAwOworCQl9CisJCXBmbl90b19tZm5fZnJhbWVfbGlz dFtrXVtqXSA9CisJCQl2aXJ0X3RvX21mbigmcGh5c190b19tYWNoaW5lX21hcHBpbmdbaV0p OworCX0KKwlIWVBFUlZJU09SX3NoYXJlZF9pbmZvLT5hcmNoLm1heF9wZm4gPSBtYXhfcGZu OworfQorCisjZWxzZSAvKiAhKGRlZmluZWQoX19pMzg2X18pIHx8IGRlZmluZWQoX194ODZf NjRfXykpICovCisKKyNkZWZpbmUgc3dpdGNoX2lkbGVfbW0oKQkoKHZvaWQpMCkKKyNkZWZp bmUgbW1fcGluX2FsbCgpCQkoKHZvaWQpMCkKKyNkZWZpbmUgcHJlX3N1c3BlbmQoKQkJKCh2 b2lkKTApCisjZGVmaW5lIHBvc3Rfc3VzcGVuZCgpCQkoKHZvaWQpMCkKKworI2VuZGlmCisK K2ludCBfX2RvX3N1c3BlbmQodm9pZCAqaWdub3JlKQoreworCWludCBlcnI7CisKKwlleHRl cm4gdm9pZCB0aW1lX3Jlc3VtZSh2b2lkKTsKKworCUJVR19PTihzbXBfcHJvY2Vzc29yX2lk KCkgIT0gMCk7CisJQlVHX09OKGluX2ludGVycnVwdCgpKTsKKworI2lmIGRlZmluZWQoX19p Mzg2X18pIHx8IGRlZmluZWQoX194ODZfNjRfXykKKwlpZiAoeGVuX2ZlYXR1cmUoWEVORkVB VF9hdXRvX3RyYW5zbGF0ZWRfcGh5c21hcCkpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAi Q2Fubm90IHN1c3BlbmQgaW4gIgorCQkgICAgICAgImF1dG9fdHJhbnNsYXRlZF9waHlzbWFw IG1vZGUuXG4iKTsKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOworCX0KKyNlbmRpZgorCisJZXJy ID0gc21wX3N1c3BlbmQoKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJeGVuYnVz X3N1c3BlbmQoKTsKKworCXByZWVtcHRfZGlzYWJsZSgpOworCisJbW1fcGluX2FsbCgpOwor CWxvY2FsX2lycV9kaXNhYmxlKCk7CisJcHJlZW1wdF9lbmFibGUoKTsKKworCWdudHRhYl9z dXNwZW5kKCk7CisKKwlwcmVfc3VzcGVuZCgpOworCisJLyoKKwkgKiBXZSdsbCBzdG9wIHNv bWV3aGVyZSBpbnNpZGUgdGhpcyBoeXBlcmNhbGwuIFdoZW4gaXQgcmV0dXJucywKKwkgKiB3 ZSdsbCBzdGFydCByZXN1bWluZyBhZnRlciB0aGUgcmVzdG9yZS4KKwkgKi8KKwlIWVBFUlZJ U09SX3N1c3BlbmQodmlydF90b19tZm4oeGVuX3N0YXJ0X2luZm8pKTsKKworCXNodXR0aW5n X2Rvd24gPSBTSFVURE9XTl9JTlZBTElEOworCisJcG9zdF9zdXNwZW5kKCk7CisKKwlnbnR0 YWJfcmVzdW1lKCk7CisKKwlpcnFfcmVzdW1lKCk7CisKKwl0aW1lX3Jlc3VtZSgpOworCisJ c3dpdGNoX2lkbGVfbW0oKTsKKworCWxvY2FsX2lycV9lbmFibGUoKTsKKworCXhlbmNvbnNf cmVzdW1lKCk7CisKKwl4ZW5idXNfcmVzdW1lKCk7CisKKwlzbXBfcmVzdW1lKCk7CisKKwly ZXR1cm4gZXJyOworfQorCitpbnQga3RocmVhZF9jcmVhdGVfb25fY3B1KGludCAoKmYpKHZv aWQgKmFyZyksCisJCQkJIHZvaWQgKmFyZywKKwkJCQkgY29uc3QgY2hhciAqbmFtZSwKKwkJ CQkgaW50IGNwdSkKK3sKKwlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnA7CisJcCA9IGt0aHJlYWRf Y3JlYXRlKGYsIGFyZywgbmFtZSk7CisJaWYgKElTX0VSUihwKSkKKwkJcmV0dXJuIFBUUl9F UlIocCk7CisJa3RocmVhZF9iaW5kKHAsIGNwdSk7CisJd2FrZV91cF9wcm9jZXNzKHApOwor CXJldHVybiAwOworfQpkaWZmIC1yIDRhMzIwZDI2ZmMyNCBsaW51eC0yLjYteGVuLXNwYXJz ZS9pbmNsdWRlL3hlbi9yZWJvb3QuaAotLS0gL2Rldi9udWxsCVRodSBKYW4gMDEgMDA6MDA6 MDAgMTk3MCArMDAwMAorKysgYi9saW51eC0yLjYteGVuLXNwYXJzZS9pbmNsdWRlL3hlbi9y ZWJvb3QuaAlGcmkgT2N0IDI3IDE3OjAyOjE5IDIwMDYgKzA5MDAKQEAgLTAsMCArMSwxOSBA QAorI2RlZmluZSBTSFVURE9XTl9JTlZBTElEICAtMQorI2RlZmluZSBTSFVURE9XTl9QT1dF Uk9GRiAgMAorI2RlZmluZSBTSFVURE9XTl9TVVNQRU5EICAgMgorLyogQ29kZSAzIGlzIFNI VVRET1dOX0NSQVNILCB3aGljaCB3ZSBkb24ndCB1c2UgYmVjYXVzZSB0aGUgZG9tYWluIGNh biBvbmx5CisgKiByZXBvcnQgYSBjcmFzaCwgbm90IGJlIGluc3RydWN0ZWQgdG8gY3Jhc2gh CisgKiBIQUxUIGlzIHRoZSBzYW1lIGFzIFBPV0VST0ZGLCBhcyBmYXIgYXMgd2UncmUgY29u Y2VybmVkLiAgVGhlIHRvb2xzIHVzZQorICogdGhlIGRpc3RpbmN0aW9uIHdoZW4gd2UgcmV0 dXJuIHRoZSByZWFzb24gY29kZSB0byB0aGVtLgorICovCisjZGVmaW5lIFNIVVRET1dOX0hB TFQgICAgICA0CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIFN0b3AvcGlja2xl IGNhbGxiYWNrIGhhbmRsaW5nLgorICovCisKKy8qIElnbm9yZSBtdWx0aXBsZSBzaHV0ZG93 biByZXF1ZXN0cy4gKi8KK3N0YXRpYyBpbnQgc2h1dHRpbmdfZG93biA9IFNIVVRET1dOX0lO VkFMSUQ7CisKK2ludCBrdGhyZWFkX2NyZWF0ZV9vbl9jcHUoaW50ICgqZikodm9pZCAqKSwg dm9pZCAqLCBjb25zdCBjaGFyICosIGludCk7CitpbnQgX19kb19zdXNwZW5kKHZvaWQgKik7 CmRpZmYgLXIgNGEzMjBkMjZmYzI0IHVubW9kaWZpZWRfZHJpdmVycy9saW51eC0yLjYvdXRp bC9LYnVpbGQKLS0tIC9kZXYvbnVsbAlUaHUgSmFuIDAxIDAwOjAwOjAwIDE5NzAgKzAwMDAK KysrIGIvdW5tb2RpZmllZF9kcml2ZXJzL2xpbnV4LTIuNi91dGlsL0tidWlsZAlGcmkgT2N0 IDI3IDE3OjAyOjE5IDIwMDYgKzA5MDAKQEAgLTAsMCArMSwzIEBACitpbmNsdWRlICQoTSkv b3ZlcnJpZGVzLm1rCisKK29iai1tIDo9IHJlYm9vdC5vCg== --------------090506020802090507080907 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 --------------090506020802090507080907--