From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933258AbdBQHSV (ORCPT ); Fri, 17 Feb 2017 02:18:21 -0500 Received: from smtprelay0241.hostedemail.com ([216.40.44.241]:33114 "EHLO smtprelay.hostedemail.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S932465AbdBQHMo (ORCPT ); Fri, 17 Feb 2017 02:12:44 -0500 X-Session-Marker: 6A6F6540706572636865732E636F6D X-Spam-Summary: 2,0,0,,d41d8cd98f00b204,joe@perches.com,:::::::::::::::::::::::::::::::::,RULES_HIT:41:69:327:355:379:421:541:800:960:966:973:988:989:1260:1345:1359:1437:1605:1730:1747:1777:1792:1801:2194:2196:2199:2200:2393:2553:2559:2562:2741:2896:2899:2904:3138:3139:3140:3141:3142:3165:3608:3865:3866:3867:3868:3870:3871:3872:4250:4321:4385:4605:5007:6117:6119:6261:6630:7875:7903:7974:8603:9040:9153:9389:10004:10848:11026:11473:11657:11658:11914:12043:12048:12296:12438:12555:12679:12683:12895:12986:13132:13231:13972:14394:21080:21324:21433:21451:30003:30019:30045:30046:30054:30056:30069:30070:30075:30079:30080:30090:30091,0,RBL:none,CacheIP:none,Bayesian:0.5,0.5,0.5,Netcheck:none,DomainCache:0,MSF:not bulk,SPF:fn,MSBL:0,DNSBL:none,Custom_rules:0:0:0,LFtime:1,LUA_SUMMARY:none X-HE-Tag: bee93_501928757b75d X-Filterd-Recvd-Size: 21539 From: Joe Perches To: Ning Sun , Steven Rostedt , Karol Herbst , Pekka Paalanen , Robert Richter , Len Brown , Boris Ostrovsky , Juergen Gross Cc: Thomas Gleixner , "H. Peter Anvin" , x86@kernel.org, linux-kernel@vger.kernel.org, tboot-devel@lists.sourceforge.net, nouveau@lists.freedesktop.org, oprofile-list@lists.sf.net, sfi-devel@simplefirmware.org, xen-devel@lists.xenproject.org Subject: [PATCH 09/35] x86: Convert remaining uses of pr_warning to pr_warn Date: Thu, 16 Feb 2017 23:11:22 -0800 Message-Id: X-Mailer: git-send-email 2.10.0.rc2.1.g053435c In-Reply-To: References: Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org To enable eventual removal of pr_warning This makes pr_warn use consistent for arch/x86 Prior to this patch, there were 46 uses of pr_warning and 122 uses of pr_warn in arch/x86 Miscellanea: o Coalesce a few formats and realign arguments o Convert a couple of multiple line printks to single line Signed-off-by: Joe Perches --- arch/x86/kernel/amd_gart_64.c | 12 +++------ arch/x86/kernel/apic/apic.c | 46 ++++++++++++++++------------------ arch/x86/kernel/apic/apic_noop.c | 2 +- arch/x86/kernel/setup_percpu.c | 4 +-- arch/x86/kernel/tboot.c | 15 ++++++----- arch/x86/kernel/tsc_sync.c | 8 +++--- arch/x86/mm/kmmio.c | 8 +++--- arch/x86/mm/mmio-mod.c | 5 ++-- arch/x86/mm/numa.c | 12 ++++----- arch/x86/mm/numa_emulation.c | 6 ++--- arch/x86/mm/testmmiotrace.c | 5 ++-- arch/x86/oprofile/op_x86_model.h | 6 ++--- arch/x86/platform/olpc/olpc-xo15-sci.c | 2 +- arch/x86/platform/sfi/sfi.c | 3 +-- arch/x86/xen/debugfs.c | 2 +- arch/x86/xen/setup.c | 2 +- 16 files changed, 63 insertions(+), 75 deletions(-) diff --git a/arch/x86/kernel/amd_gart_64.c b/arch/x86/kernel/amd_gart_64.c index 63ff468a7986..6bb37027cd70 100644 --- a/arch/x86/kernel/amd_gart_64.c +++ b/arch/x86/kernel/amd_gart_64.c @@ -535,10 +535,8 @@ static __init unsigned long check_iommu_size(unsigned long aper, u64 aper_size) iommu_size -= round_up(a, PMD_PAGE_SIZE) - a; if (iommu_size < 64*1024*1024) { - pr_warning( - "PCI-DMA: Warning: Small IOMMU %luMB." - " Consider increasing the AGP aperture in BIOS\n", - iommu_size >> 20); + pr_warn("PCI-DMA: Warning: Small IOMMU %luMB. Consider increasing the AGP aperture in BIOS\n", + iommu_size >> 20); } return iommu_size; @@ -690,8 +688,7 @@ static __init int init_amd_gatt(struct agp_kern_info *info) nommu: /* Should not happen anymore */ - pr_warning("PCI-DMA: More than 4GB of RAM and no IOMMU\n" - "falling back to iommu=soft.\n"); + pr_warn("PCI-DMA: More than 4GB of RAM and no IOMMU - falling back to iommu=soft\n"); return -1; } @@ -756,8 +753,7 @@ int __init gart_iommu_init(void) !gart_iommu_aperture || (no_agp && init_amd_gatt(&info) < 0)) { if (max_pfn > MAX_DMA32_PFN) { - pr_warning("More than 4GB of memory but GART IOMMU not available.\n"); - pr_warning("falling back to iommu=soft.\n"); + pr_warn("More than 4GB of memory but GART IOMMU not available - falling back to iommu=soft\n"); } return 0; } diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c index 4261b3282ad9..37e9129da8b3 100644 --- a/arch/x86/kernel/apic/apic.c +++ b/arch/x86/kernel/apic/apic.c @@ -685,8 +685,8 @@ calibrate_by_pmtimer(long deltapm, long *delta, long *deltatsc) res = (((u64)deltapm) * mult) >> 22; do_div(res, 1000000); - pr_warning("APIC calibration not consistent " - "with PM-Timer: %ldms instead of 100ms\n",(long)res); + pr_warn("APIC calibration not consistent with PM-Timer: %ldms instead of 100ms\n", + (long)res); /* Correct the lapic counter value */ res = (((u64)(*delta)) * pm_100ms); @@ -805,7 +805,7 @@ static int __init calibrate_APIC_clock(void) */ if (lapic_timer_frequency < (1000000 / HZ)) { local_irq_enable(); - pr_warning("APIC frequency too slow, disabling apic timer\n"); + pr_warn("APIC frequency too slow, disabling apic timer\n"); return -1; } @@ -848,8 +848,8 @@ static int __init calibrate_APIC_clock(void) local_irq_enable(); if (levt->features & CLOCK_EVT_FEAT_DUMMY) { - pr_warning("APIC timer disabled due to verification failure\n"); - return -1; + pr_warn("APIC timer disabled due to verification failure\n"); + return -1; } return 0; @@ -923,7 +923,7 @@ static void local_apic_timer_interrupt(void) * spurious. */ if (!evt->event_handler) { - pr_warning("Spurious LAPIC timer interrupt on cpu %d\n", cpu); + pr_warn("Spurious LAPIC timer interrupt on cpu %d\n", cpu); /* Switch it off */ lapic_timer_shutdown(evt); return; @@ -1503,11 +1503,11 @@ static int __init setup_nox2apic(char *str) int apicid = native_apic_msr_read(APIC_ID); if (apicid >= 255) { - pr_warning("Apicid: %08x, cannot enforce nox2apic\n", - apicid); + pr_warn("Apicid: %08x, cannot enforce nox2apic\n", + apicid); return 0; } - pr_warning("x2apic already enabled.\n"); + pr_warn("x2apic already enabled\n"); __x2apic_disable(); } setup_clear_cpu_cap(X86_FEATURE_X2APIC); @@ -1684,7 +1684,7 @@ static int __init apic_verify(void) */ features = cpuid_edx(1); if (!(features & (1 << X86_FEATURE_APIC))) { - pr_warning("Could not enable APIC!\n"); + pr_warn("Could not enable APIC!\n"); return -1; } set_cpu_cap(&boot_cpu_data, X86_FEATURE_APIC); @@ -2102,9 +2102,8 @@ int __generic_processor_info(int apicid, int version, bool enabled) disabled_cpu_apicid == apicid) { int thiscpu = num_processors + disabled_cpus; - pr_warning("APIC: Disabling requested cpu." - " Processor %d/0x%x ignored.\n", - thiscpu, apicid); + pr_warn("APIC: Disabling requested cpu - Processor %d/0x%x ignored\n", + thiscpu, apicid); disabled_cpus++; return -ENODEV; @@ -2118,10 +2117,8 @@ int __generic_processor_info(int apicid, int version, bool enabled) apicid != boot_cpu_physical_apicid) { int thiscpu = max + disabled_cpus - 1; - pr_warning( - "APIC: NR_CPUS/possible_cpus limit of %i almost" - " reached. Keeping one slot for boot cpu." - " Processor %d/0x%x ignored.\n", max, thiscpu, apicid); + pr_warn("APIC: NR_CPUS/possible_cpus limit of %i almost reached. Keeping one slot for boot cpu. Processor %d/0x%x ignored.\n", + max, thiscpu, apicid); disabled_cpus++; return -ENODEV; @@ -2131,9 +2128,8 @@ int __generic_processor_info(int apicid, int version, bool enabled) int thiscpu = max + disabled_cpus; if (enabled) { - pr_warning("APIC: NR_CPUS/possible_cpus limit of %i " - "reached. Processor %d/0x%x ignored.\n", - max, thiscpu, apicid); + pr_warn("APIC: NR_CPUS/possible_cpus limit of %i reached. Processor %d/0x%x ignored.\n", + max, thiscpu, apicid); } disabled_cpus++; @@ -2164,13 +2160,13 @@ int __generic_processor_info(int apicid, int version, bool enabled) * Validate version */ if (version == 0x0) { - pr_warning("BIOS bug: APIC version is 0 for CPU %d/0x%x, fixing up to 0x10\n", - cpu, apicid); + pr_warn("BIOS bug: APIC version is 0 for CPU %d/0x%x, fixing up to 0x10\n", + cpu, apicid); version = 0x10; } if (version != boot_cpu_apic_version) { - pr_warning("BIOS bug: APIC version mismatch, boot CPU: %x, CPU %d: version %x\n", + pr_warn("BIOS bug: APIC version mismatch, boot CPU: %x, CPU %d: version %x\n", boot_cpu_apic_version, cpu, version); } @@ -2625,8 +2621,8 @@ static int __init apic_set_verbosity(char *arg) else if (strcmp("verbose", arg) == 0) apic_verbosity = APIC_VERBOSE; else { - pr_warning("APIC Verbosity level %s not recognised" - " use apic=verbose or apic=debug\n", arg); + pr_warn("APIC Verbosity level %s not recognised use apic=verbose or apic=debug\n", + arg); return -EINVAL; } diff --git a/arch/x86/kernel/apic/apic_noop.c b/arch/x86/kernel/apic/apic_noop.c index b109e4389c92..47b6e5a0b574 100644 --- a/arch/x86/kernel/apic/apic_noop.c +++ b/arch/x86/kernel/apic/apic_noop.c @@ -93,7 +93,7 @@ static void noop_vector_allocation_domain(int cpu, struct cpumask *retmask, const struct cpumask *mask) { if (cpu != 0) - pr_warning("APIC: Vector allocated for non-BSP cpu\n"); + pr_warn("APIC: Vector allocated for non-BSP cpu\n"); cpumask_copy(retmask, cpumask_of(cpu)); } diff --git a/arch/x86/kernel/setup_percpu.c b/arch/x86/kernel/setup_percpu.c index 9820d6d977c6..e04562c44134 100644 --- a/arch/x86/kernel/setup_percpu.c +++ b/arch/x86/kernel/setup_percpu.c @@ -207,8 +207,8 @@ void __init setup_per_cpu_areas(void) pcpu_cpu_distance, pcpu_fc_alloc, pcpu_fc_free); if (rc < 0) - pr_warning("%s allocator failed (%d), falling back to page size\n", - pcpu_fc_names[pcpu_chosen_fc], rc); + pr_warn("%s allocator failed (%d), falling back to page size\n", + pcpu_fc_names[pcpu_chosen_fc], rc); } if (rc < 0) rc = pcpu_page_first_chunk(PERCPU_FIRST_CHUNK_RESERVE, diff --git a/arch/x86/kernel/tboot.c b/arch/x86/kernel/tboot.c index b868fa1b812b..a6b57d8d0b9b 100644 --- a/arch/x86/kernel/tboot.c +++ b/arch/x86/kernel/tboot.c @@ -70,7 +70,7 @@ void __init tboot_probe(void) */ if (!e820_any_mapped(boot_params.tboot_addr, boot_params.tboot_addr, E820_RESERVED)) { - pr_warning("non-0 tboot_addr but it is not of type E820_RESERVED\n"); + pr_warn("non-0 tboot_addr but it is not of type E820_RESERVED\n"); return; } @@ -78,13 +78,12 @@ void __init tboot_probe(void) set_fixmap(FIX_TBOOT_BASE, boot_params.tboot_addr); tboot = (struct tboot *)fix_to_virt(FIX_TBOOT_BASE); if (memcmp(&tboot_uuid, &tboot->uuid, sizeof(tboot->uuid))) { - pr_warning("tboot at 0x%llx is invalid\n", - boot_params.tboot_addr); + pr_warn("tboot at 0x%llx is invalid\n", boot_params.tboot_addr); tboot = NULL; return; } if (tboot->version < 5) { - pr_warning("tboot version is invalid: %u\n", tboot->version); + pr_warn("tboot version is invalid: %u\n", tboot->version); tboot = NULL; return; } @@ -287,7 +286,7 @@ static int tboot_sleep(u8 sleep_state, u32 pm1a_control, u32 pm1b_control) if (sleep_state >= ACPI_S_STATE_COUNT || acpi_shutdown_map[sleep_state] == -1) { - pr_warning("unsupported sleep state 0x%x\n", sleep_state); + pr_warn("unsupported sleep state 0x%x\n", sleep_state); return -1; } @@ -300,7 +299,7 @@ static int tboot_extended_sleep(u8 sleep_state, u32 val_a, u32 val_b) if (!tboot_enabled()) return 0; - pr_warning("tboot is not able to suspend on platforms with reduced hardware sleep (ACPIv5)"); + pr_warn("tboot is not able to suspend on platforms with reduced hardware sleep (ACPIv5)\n"); return -ENODEV; } @@ -318,7 +317,7 @@ static int tboot_wait_for_aps(int num_aps) } if (timeout) - pr_warning("tboot wait for APs timeout\n"); + pr_warn("tboot wait for APs timeout\n"); return !(atomic_read((atomic_t *)&tboot->num_in_wfs) == num_aps); } @@ -511,7 +510,7 @@ int tboot_force_iommu(void) return 0; if (no_iommu || swiotlb || dmar_disabled) - pr_warning("Forcing Intel-IOMMU to enabled\n"); + pr_warn("Forcing Intel-IOMMU to enabled\n"); dmar_disabled = 0; #ifdef CONFIG_SWIOTLB diff --git a/arch/x86/kernel/tsc_sync.c b/arch/x86/kernel/tsc_sync.c index 728f75378475..61de4fbf8f45 100644 --- a/arch/x86/kernel/tsc_sync.c +++ b/arch/x86/kernel/tsc_sync.c @@ -332,12 +332,12 @@ void check_tsc_sync_source(int cpu) /* Force it to 0 if random warps brought us here */ atomic_set(&test_runs, 0); - pr_warning("TSC synchronization [CPU#%d -> CPU#%d]:\n", + pr_warn("TSC synchronization [CPU#%d -> CPU#%d]:\n", smp_processor_id(), cpu); - pr_warning("Measured %Ld cycles TSC warp between CPUs, " - "turning off TSC clock.\n", max_warp); + pr_warn("Measured %lld cycles TSC warp between CPUs, turning off TSC clock\n", + max_warp); if (random_warps) - pr_warning("TSC warped randomly between CPUs\n"); + pr_warn("TSC warped randomly between CPUs\n"); mark_tsc_unstable("check_tsc_sync_source failed"); } diff --git a/arch/x86/mm/kmmio.c b/arch/x86/mm/kmmio.c index afc47f5c9531..ad70518cdcc7 100644 --- a/arch/x86/mm/kmmio.c +++ b/arch/x86/mm/kmmio.c @@ -187,8 +187,8 @@ static int arm_kmmio_fault_page(struct kmmio_fault_page *f) int ret; WARN_ONCE(f->armed, KERN_ERR pr_fmt("kmmio page already armed.\n")); if (f->armed) { - pr_warning("double-arm: addr 0x%08lx, ref %d, old %d\n", - f->addr, f->count, !!f->old_presence); + pr_warn("double-arm: addr 0x%08lx, ref %d, old %d\n", + f->addr, f->count, !!f->old_presence); } ret = clear_page_presence(f, true); WARN_ONCE(ret < 0, KERN_ERR pr_fmt("arming at 0x%08lx failed.\n"), @@ -335,8 +335,8 @@ static int post_kmmio_handler(unsigned long condition, struct pt_regs *regs) * something external causing them (f.e. using a debugger while * mmio tracing enabled), or erroneous behaviour */ - pr_warning("unexpected debug trap on CPU %d.\n", - smp_processor_id()); + pr_warn("unexpected debug trap on CPU %d\n", + smp_processor_id()); goto out; } diff --git a/arch/x86/mm/mmio-mod.c b/arch/x86/mm/mmio-mod.c index bef36622e408..706ae44d1af7 100644 --- a/arch/x86/mm/mmio-mod.c +++ b/arch/x86/mm/mmio-mod.c @@ -407,7 +407,7 @@ static void enter_uniprocessor(void) } out: if (num_online_cpus() > 1) - pr_warning("multiple CPUs still online, may miss events.\n"); + pr_warn("multiple CPUs still online, may miss events\n"); } static void leave_uniprocessor(void) @@ -431,8 +431,7 @@ static void leave_uniprocessor(void) static void enter_uniprocessor(void) { if (num_online_cpus() > 1) - pr_warning("multiple CPUs are online, may miss events. " - "Suggest booting with maxcpus=1 kernel argument.\n"); + pr_warn("multiple CPUs are online, may miss events. Suggest booting with maxcpus=1 kernel argument.\n"); } static void leave_uniprocessor(void) diff --git a/arch/x86/mm/numa.c b/arch/x86/mm/numa.c index 12dcad7297a5..3aa236f0a2fb 100644 --- a/arch/x86/mm/numa.c +++ b/arch/x86/mm/numa.c @@ -136,8 +136,8 @@ static int __init numa_add_memblk_to(int nid, u64 start, u64 end, /* whine about and ignore invalid blks */ if (start > end || nid < 0 || nid >= MAX_NUMNODES) { - pr_warning("NUMA: Warning: invalid memblk node %d [mem %#010Lx-%#010Lx]\n", - nid, start, end - 1); + pr_warn("NUMA: Warning: invalid memblk node %d [mem %#010Lx-%#010Lx]\n", + nid, start, end - 1); return 0; } @@ -272,9 +272,9 @@ int __init numa_cleanup_meminfo(struct numa_meminfo *mi) bj->nid, bj->start, bj->end - 1); return -EINVAL; } - pr_warning("NUMA: Warning: node %d [mem %#010Lx-%#010Lx] overlaps with itself [mem %#010Lx-%#010Lx]\n", - bi->nid, bi->start, bi->end - 1, - bj->start, bj->end - 1); + pr_warn("NUMA: Warning: node %d [mem %#010Lx-%#010Lx] overlaps with itself [mem %#010Lx-%#010Lx]\n", + bi->nid, bi->start, bi->end - 1, + bj->start, bj->end - 1); } /* @@ -364,7 +364,7 @@ static int __init numa_alloc_distance(void) phys = memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped), size, PAGE_SIZE); if (!phys) { - pr_warning("NUMA: Warning: can't allocate distance table!\n"); + pr_warn("NUMA: Warning: can't allocate distance table!\n"); /* don't retry until explicitly reset */ numa_distance = (void *)1LU; return -ENOMEM; diff --git a/arch/x86/mm/numa_emulation.c b/arch/x86/mm/numa_emulation.c index a8f90ce3dedf..a6446ad3cd32 100644 --- a/arch/x86/mm/numa_emulation.c +++ b/arch/x86/mm/numa_emulation.c @@ -349,7 +349,7 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt) goto no_emu; if (numa_cleanup_meminfo(&ei) < 0) { - pr_warning("NUMA: Warning: constructed meminfo invalid, disabling emulation\n"); + pr_warn("NUMA: Warning: constructed meminfo invalid, disabling emulation\n"); goto no_emu; } @@ -360,7 +360,7 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt) phys = memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped), phys_size, PAGE_SIZE); if (!phys) { - pr_warning("NUMA: Warning: can't allocate copy of distance table, disabling emulation\n"); + pr_warn("NUMA: Warning: can't allocate copy of distance table, disabling emulation\n"); goto no_emu; } memblock_reserve(phys, phys_size); @@ -386,7 +386,7 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt) } } if (dfl_phys_nid == NUMA_NO_NODE) { - pr_warning("NUMA: Warning: can't determine default physical node, disabling emulation\n"); + pr_warn("NUMA: Warning: can't determine default physical node, disabling emulation\n"); goto no_emu; } diff --git a/arch/x86/mm/testmmiotrace.c b/arch/x86/mm/testmmiotrace.c index 38868adf07ea..4a55e453296d 100644 --- a/arch/x86/mm/testmmiotrace.c +++ b/arch/x86/mm/testmmiotrace.c @@ -121,9 +121,8 @@ static int __init init(void) return -ENXIO; } - pr_warning("WARNING: mapping %lu kB @ 0x%08lx in PCI address space, " - "and writing 16 kB of rubbish in there.\n", - size >> 10, mmio_address); + pr_warn("WARNING: mapping %lu kB @ 0x%08lx in PCI address space, and writing 16 kB of rubbish in there\n", + size >> 10, mmio_address); do_test(size); do_test_bulk_ioremapping(); pr_info("All done.\n"); diff --git a/arch/x86/oprofile/op_x86_model.h b/arch/x86/oprofile/op_x86_model.h index 71e8a67337e2..276cf79b5d24 100644 --- a/arch/x86/oprofile/op_x86_model.h +++ b/arch/x86/oprofile/op_x86_model.h @@ -67,13 +67,13 @@ static inline void op_x86_warn_in_use(int counter) * cannot be monitored by any other counter, contact your * hardware or BIOS vendor. */ - pr_warning("oprofile: counter #%d on cpu #%d may already be used\n", - counter, smp_processor_id()); + pr_warn("oprofile: counter #%d on cpu #%d may already be used\n", + counter, smp_processor_id()); } static inline void op_x86_warn_reserved(int counter) { - pr_warning("oprofile: counter #%d is already reserved\n", counter); + pr_warn("oprofile: counter #%d is already reserved\n", counter); } extern u64 op_x86_get_ctrl(struct op_x86_model_spec const *model, diff --git a/arch/x86/platform/olpc/olpc-xo15-sci.c b/arch/x86/platform/olpc/olpc-xo15-sci.c index c0533fbc39e3..e46c73ba3b44 100644 --- a/arch/x86/platform/olpc/olpc-xo15-sci.c +++ b/arch/x86/platform/olpc/olpc-xo15-sci.c @@ -43,7 +43,7 @@ static int set_lid_wake_behavior(bool wake_on_close) status = acpi_execute_simple_method(NULL, "\\_SB.PCI0.LID.LIDW", wake_on_close); if (ACPI_FAILURE(status)) { - pr_warning(PFX "failed to set lid behavior\n"); + pr_warn(PFX "failed to set lid behavior\n"); return 1; } diff --git a/arch/x86/platform/sfi/sfi.c b/arch/x86/platform/sfi/sfi.c index 6c7111bbd1e9..530655e8405e 100644 --- a/arch/x86/platform/sfi/sfi.c +++ b/arch/x86/platform/sfi/sfi.c @@ -39,8 +39,7 @@ static unsigned long sfi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE; static void __init mp_sfi_register_lapic(u8 id) { if (MAX_LOCAL_APIC - id <= 0) { - pr_warning("Processor #%d invalid (max %d)\n", - id, MAX_LOCAL_APIC); + pr_warn("Processor #%d invalid (max %d)\n", id, MAX_LOCAL_APIC); return; } diff --git a/arch/x86/xen/debugfs.c b/arch/x86/xen/debugfs.c index 1daff5545c0a..358f92da8d9e 100644 --- a/arch/x86/xen/debugfs.c +++ b/arch/x86/xen/debugfs.c @@ -12,7 +12,7 @@ struct dentry * __init xen_init_debugfs(void) d_xen_debug = debugfs_create_dir("xen", NULL); if (!d_xen_debug) - pr_warning("Could not create 'xen' debugfs directory\n"); + pr_warn("Could not create 'xen' debugfs directory\n"); } return d_xen_debug; diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c index a8c306cf8868..b92e924b9464 100644 --- a/arch/x86/xen/setup.c +++ b/arch/x86/xen/setup.c @@ -413,7 +413,7 @@ static unsigned long __init xen_set_identity_and_remap_chunk( remap_range_size = xen_find_pfn_range(&remap_pfn); if (!remap_range_size) { - pr_warning("Unable to find available pfn range, not remapping identity pages\n"); + pr_warn("Unable to find available pfn range, not remapping identity pages\n"); xen_set_identity_and_release_chunk(cur_pfn, cur_pfn + left, nr_pages); break; -- 2.10.0.rc2.1.g053435c From mboxrd@z Thu Jan 1 00:00:00 1970 From: Joe Perches Subject: [PATCH 09/35] x86: Convert remaining uses of pr_warning to pr_warn Date: Thu, 16 Feb 2017 23:11:22 -0800 Message-ID: References: Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: Ning Sun , Steven Rostedt , Karol Herbst , Pekka Paalanen , Robert Richter , Len Brown , Boris Ostrovsky , Juergen Gross Cc: nouveau@lists.freedesktop.org, x86@kernel.org, linux-kernel@vger.kernel.org, tboot-devel@lists.sourceforge.net, oprofile-list@lists.sf.net, "H. Peter Anvin" , xen-devel@lists.xenproject.org, Thomas Gleixner , sfi-devel@simplefirmware.org List-Id: nouveau.vger.kernel.org VG8gZW5hYmxlIGV2ZW50dWFsIHJlbW92YWwgb2YgcHJfd2FybmluZwoKVGhpcyBtYWtlcyBwcl93 YXJuIHVzZSBjb25zaXN0ZW50IGZvciBhcmNoL3g4NgoKUHJpb3IgdG8gdGhpcyBwYXRjaCwgdGhl cmUgd2VyZSA0NiB1c2VzIG9mIHByX3dhcm5pbmcgYW5kCjEyMiB1c2VzIG9mIHByX3dhcm4gaW4g YXJjaC94ODYKCk1pc2NlbGxhbmVhOgoKbyBDb2FsZXNjZSBhIGZldyBmb3JtYXRzIGFuZCByZWFs aWduIGFyZ3VtZW50cwpvIENvbnZlcnQgYSBjb3VwbGUgb2YgbXVsdGlwbGUgbGluZSBwcmludGtz IHRvIHNpbmdsZSBsaW5lCgpTaWduZWQtb2ZmLWJ5OiBKb2UgUGVyY2hlcyA8am9lQHBlcmNoZXMu Y29tPgotLS0KIGFyY2gveDg2L2tlcm5lbC9hbWRfZ2FydF82NC5jICAgICAgICAgIHwgMTIgKysr LS0tLS0tCiBhcmNoL3g4Ni9rZXJuZWwvYXBpYy9hcGljLmMgICAgICAgICAgICB8IDQ2ICsrKysr KysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0KIGFyY2gveDg2L2tlcm5lbC9hcGljL2FwaWNf bm9vcC5jICAgICAgIHwgIDIgKy0KIGFyY2gveDg2L2tlcm5lbC9zZXR1cF9wZXJjcHUuYyAgICAg ICAgIHwgIDQgKy0tCiBhcmNoL3g4Ni9rZXJuZWwvdGJvb3QuYyAgICAgICAgICAgICAgICB8IDE1 ICsrKysrKy0tLS0tCiBhcmNoL3g4Ni9rZXJuZWwvdHNjX3N5bmMuYyAgICAgICAgICAgICB8ICA4 ICsrKy0tLQogYXJjaC94ODYvbW0va21taW8uYyAgICAgICAgICAgICAgICAgICAgfCAgOCArKyst LS0KIGFyY2gveDg2L21tL21taW8tbW9kLmMgICAgICAgICAgICAgICAgIHwgIDUgKystLQogYXJj aC94ODYvbW0vbnVtYS5jICAgICAgICAgICAgICAgICAgICAgfCAxMiArKysrLS0tLS0KIGFyY2gv eDg2L21tL251bWFfZW11bGF0aW9uLmMgICAgICAgICAgIHwgIDYgKystLS0KIGFyY2gveDg2L21t L3Rlc3RtbWlvdHJhY2UuYyAgICAgICAgICAgIHwgIDUgKystLQogYXJjaC94ODYvb3Byb2ZpbGUv b3BfeDg2X21vZGVsLmggICAgICAgfCAgNiArKy0tLQogYXJjaC94ODYvcGxhdGZvcm0vb2xwYy9v bHBjLXhvMTUtc2NpLmMgfCAgMiArLQogYXJjaC94ODYvcGxhdGZvcm0vc2ZpL3NmaS5jICAgICAg ICAgICAgfCAgMyArLS0KIGFyY2gveDg2L3hlbi9kZWJ1Z2ZzLmMgICAgICAgICAgICAgICAgIHwg IDIgKy0KIGFyY2gveDg2L3hlbi9zZXR1cC5jICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIDE2 IGZpbGVzIGNoYW5nZWQsIDYzIGluc2VydGlvbnMoKyksIDc1IGRlbGV0aW9ucygtKQoKZGlmZiAt LWdpdCBhL2FyY2gveDg2L2tlcm5lbC9hbWRfZ2FydF82NC5jIGIvYXJjaC94ODYva2VybmVsL2Ft ZF9nYXJ0XzY0LmMKaW5kZXggNjNmZjQ2OGE3OTg2Li42YmIzNzAyN2NkNzAgMTAwNjQ0Ci0tLSBh L2FyY2gveDg2L2tlcm5lbC9hbWRfZ2FydF82NC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9hbWRf Z2FydF82NC5jCkBAIC01MzUsMTAgKzUzNSw4IEBAIHN0YXRpYyBfX2luaXQgdW5zaWduZWQgbG9u ZyBjaGVja19pb21tdV9zaXplKHVuc2lnbmVkIGxvbmcgYXBlciwgdTY0IGFwZXJfc2l6ZSkKIAlp b21tdV9zaXplIC09IHJvdW5kX3VwKGEsIFBNRF9QQUdFX1NJWkUpIC0gYTsKIAogCWlmIChpb21t dV9zaXplIDwgNjQqMTAyNCoxMDI0KSB7Ci0JCXByX3dhcm5pbmcoCi0JCQkiUENJLURNQTogV2Fy bmluZzogU21hbGwgSU9NTVUgJWx1TUIuIgotCQkJIiBDb25zaWRlciBpbmNyZWFzaW5nIHRoZSBB R1AgYXBlcnR1cmUgaW4gQklPU1xuIiwKLQkJCQlpb21tdV9zaXplID4+IDIwKTsKKwkJcHJfd2Fy bigiUENJLURNQTogV2FybmluZzogU21hbGwgSU9NTVUgJWx1TUIuIENvbnNpZGVyIGluY3JlYXNp bmcgdGhlIEFHUCBhcGVydHVyZSBpbiBCSU9TXG4iLAorCQkJaW9tbXVfc2l6ZSA+PiAyMCk7CiAJ fQogCiAJcmV0dXJuIGlvbW11X3NpemU7CkBAIC02OTAsOCArNjg4LDcgQEAgc3RhdGljIF9faW5p dCBpbnQgaW5pdF9hbWRfZ2F0dChzdHJ1Y3QgYWdwX2tlcm5faW5mbyAqaW5mbykKIAogIG5vbW11 OgogCS8qIFNob3VsZCBub3QgaGFwcGVuIGFueW1vcmUgKi8KLQlwcl93YXJuaW5nKCJQQ0ktRE1B OiBNb3JlIHRoYW4gNEdCIG9mIFJBTSBhbmQgbm8gSU9NTVVcbiIKLQkgICAgICAgImZhbGxpbmcg YmFjayB0byBpb21tdT1zb2Z0LlxuIik7CisJcHJfd2FybigiUENJLURNQTogTW9yZSB0aGFuIDRH QiBvZiBSQU0gYW5kIG5vIElPTU1VIC0gZmFsbGluZyBiYWNrIHRvIGlvbW11PXNvZnRcbiIpOwog CXJldHVybiAtMTsKIH0KIApAQCAtNzU2LDggKzc1Myw3IEBAIGludCBfX2luaXQgZ2FydF9pb21t dV9pbml0KHZvaWQpCiAJICAgICFnYXJ0X2lvbW11X2FwZXJ0dXJlIHx8CiAJICAgIChub19hZ3Ag JiYgaW5pdF9hbWRfZ2F0dCgmaW5mbykgPCAwKSkgewogCQlpZiAobWF4X3BmbiA+IE1BWF9ETUEz Ml9QRk4pIHsKLQkJCXByX3dhcm5pbmcoIk1vcmUgdGhhbiA0R0Igb2YgbWVtb3J5IGJ1dCBHQVJU IElPTU1VIG5vdCBhdmFpbGFibGUuXG4iKTsKLQkJCXByX3dhcm5pbmcoImZhbGxpbmcgYmFjayB0 byBpb21tdT1zb2Z0LlxuIik7CisJCQlwcl93YXJuKCJNb3JlIHRoYW4gNEdCIG9mIG1lbW9yeSBi dXQgR0FSVCBJT01NVSBub3QgYXZhaWxhYmxlIC0gZmFsbGluZyBiYWNrIHRvIGlvbW11PXNvZnRc biIpOwogCQl9CiAJCXJldHVybiAwOwogCX0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9h cGljL2FwaWMuYyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYwppbmRleCA0MjYxYjMyODJh ZDkuLjM3ZTkxMjlkYThiMyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2FwaWMvYXBpYy5j CisrKyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYwpAQCAtNjg1LDggKzY4NSw4IEBAIGNh bGlicmF0ZV9ieV9wbXRpbWVyKGxvbmcgZGVsdGFwbSwgbG9uZyAqZGVsdGEsIGxvbmcgKmRlbHRh dHNjKQogCiAJcmVzID0gKCgodTY0KWRlbHRhcG0pICogIG11bHQpID4+IDIyOwogCWRvX2Rpdihy ZXMsIDEwMDAwMDApOwotCXByX3dhcm5pbmcoIkFQSUMgY2FsaWJyYXRpb24gbm90IGNvbnNpc3Rl bnQgIgotCQkgICAid2l0aCBQTS1UaW1lcjogJWxkbXMgaW5zdGVhZCBvZiAxMDBtc1xuIiwobG9u ZylyZXMpOworCXByX3dhcm4oIkFQSUMgY2FsaWJyYXRpb24gbm90IGNvbnNpc3RlbnQgd2l0aCBQ TS1UaW1lcjogJWxkbXMgaW5zdGVhZCBvZiAxMDBtc1xuIiwKKwkJKGxvbmcpcmVzKTsKIAogCS8q IENvcnJlY3QgdGhlIGxhcGljIGNvdW50ZXIgdmFsdWUgKi8KIAlyZXMgPSAoKCh1NjQpKCpkZWx0 YSkpICogcG1fMTAwbXMpOwpAQCAtODA1LDcgKzgwNSw3IEBAIHN0YXRpYyBpbnQgX19pbml0IGNh bGlicmF0ZV9BUElDX2Nsb2NrKHZvaWQpCiAJICovCiAJaWYgKGxhcGljX3RpbWVyX2ZyZXF1ZW5j eSA8ICgxMDAwMDAwIC8gSFopKSB7CiAJCWxvY2FsX2lycV9lbmFibGUoKTsKLQkJcHJfd2Fybmlu ZygiQVBJQyBmcmVxdWVuY3kgdG9vIHNsb3csIGRpc2FibGluZyBhcGljIHRpbWVyXG4iKTsKKwkJ cHJfd2FybigiQVBJQyBmcmVxdWVuY3kgdG9vIHNsb3csIGRpc2FibGluZyBhcGljIHRpbWVyXG4i KTsKIAkJcmV0dXJuIC0xOwogCX0KIApAQCAtODQ4LDggKzg0OCw4IEBAIHN0YXRpYyBpbnQgX19p bml0IGNhbGlicmF0ZV9BUElDX2Nsb2NrKHZvaWQpCiAJbG9jYWxfaXJxX2VuYWJsZSgpOwogCiAJ aWYgKGxldnQtPmZlYXR1cmVzICYgQ0xPQ0tfRVZUX0ZFQVRfRFVNTVkpIHsKLQkJcHJfd2Fybmlu ZygiQVBJQyB0aW1lciBkaXNhYmxlZCBkdWUgdG8gdmVyaWZpY2F0aW9uIGZhaWx1cmVcbiIpOwot CQkJcmV0dXJuIC0xOworCQlwcl93YXJuKCJBUElDIHRpbWVyIGRpc2FibGVkIGR1ZSB0byB2ZXJp ZmljYXRpb24gZmFpbHVyZVxuIik7CisJCXJldHVybiAtMTsKIAl9CiAKIAlyZXR1cm4gMDsKQEAg LTkyMyw3ICs5MjMsNyBAQCBzdGF0aWMgdm9pZCBsb2NhbF9hcGljX3RpbWVyX2ludGVycnVwdCh2 b2lkKQogCSAqIHNwdXJpb3VzLgogCSAqLwogCWlmICghZXZ0LT5ldmVudF9oYW5kbGVyKSB7Ci0J CXByX3dhcm5pbmcoIlNwdXJpb3VzIExBUElDIHRpbWVyIGludGVycnVwdCBvbiBjcHUgJWRcbiIs IGNwdSk7CisJCXByX3dhcm4oIlNwdXJpb3VzIExBUElDIHRpbWVyIGludGVycnVwdCBvbiBjcHUg JWRcbiIsIGNwdSk7CiAJCS8qIFN3aXRjaCBpdCBvZmYgKi8KIAkJbGFwaWNfdGltZXJfc2h1dGRv d24oZXZ0KTsKIAkJcmV0dXJuOwpAQCAtMTUwMywxMSArMTUwMywxMSBAQCBzdGF0aWMgaW50IF9f aW5pdCBzZXR1cF9ub3gyYXBpYyhjaGFyICpzdHIpCiAJCWludCBhcGljaWQgPSBuYXRpdmVfYXBp Y19tc3JfcmVhZChBUElDX0lEKTsKIAogCQlpZiAoYXBpY2lkID49IDI1NSkgewotCQkJcHJfd2Fy bmluZygiQXBpY2lkOiAlMDh4LCBjYW5ub3QgZW5mb3JjZSBub3gyYXBpY1xuIiwKLQkJCQkgICBh cGljaWQpOworCQkJcHJfd2FybigiQXBpY2lkOiAlMDh4LCBjYW5ub3QgZW5mb3JjZSBub3gyYXBp Y1xuIiwKKwkJCQlhcGljaWQpOwogCQkJcmV0dXJuIDA7CiAJCX0KLQkJcHJfd2FybmluZygieDJh cGljIGFscmVhZHkgZW5hYmxlZC5cbiIpOworCQlwcl93YXJuKCJ4MmFwaWMgYWxyZWFkeSBlbmFi bGVkXG4iKTsKIAkJX194MmFwaWNfZGlzYWJsZSgpOwogCX0KIAlzZXR1cF9jbGVhcl9jcHVfY2Fw KFg4Nl9GRUFUVVJFX1gyQVBJQyk7CkBAIC0xNjg0LDcgKzE2ODQsNyBAQCBzdGF0aWMgaW50IF9f aW5pdCBhcGljX3ZlcmlmeSh2b2lkKQogCSAqLwogCWZlYXR1cmVzID0gY3B1aWRfZWR4KDEpOwog CWlmICghKGZlYXR1cmVzICYgKDEgPDwgWDg2X0ZFQVRVUkVfQVBJQykpKSB7Ci0JCXByX3dhcm5p bmcoIkNvdWxkIG5vdCBlbmFibGUgQVBJQyFcbiIpOworCQlwcl93YXJuKCJDb3VsZCBub3QgZW5h YmxlIEFQSUMhXG4iKTsKIAkJcmV0dXJuIC0xOwogCX0KIAlzZXRfY3B1X2NhcCgmYm9vdF9jcHVf ZGF0YSwgWDg2X0ZFQVRVUkVfQVBJQyk7CkBAIC0yMTAyLDkgKzIxMDIsOCBAQCBpbnQgX19nZW5l cmljX3Byb2Nlc3Nvcl9pbmZvKGludCBhcGljaWQsIGludCB2ZXJzaW9uLCBib29sIGVuYWJsZWQp CiAJICAgIGRpc2FibGVkX2NwdV9hcGljaWQgPT0gYXBpY2lkKSB7CiAJCWludCB0aGlzY3B1ID0g bnVtX3Byb2Nlc3NvcnMgKyBkaXNhYmxlZF9jcHVzOwogCi0JCXByX3dhcm5pbmcoIkFQSUM6IERp c2FibGluZyByZXF1ZXN0ZWQgY3B1LiIKLQkJCSAgICIgUHJvY2Vzc29yICVkLzB4JXggaWdub3Jl ZC5cbiIsCi0JCQkgICB0aGlzY3B1LCBhcGljaWQpOworCQlwcl93YXJuKCJBUElDOiBEaXNhYmxp bmcgcmVxdWVzdGVkIGNwdSAtIFByb2Nlc3NvciAlZC8weCV4IGlnbm9yZWRcbiIsCisJCQl0aGlz Y3B1LCBhcGljaWQpOwogCiAJCWRpc2FibGVkX2NwdXMrKzsKIAkJcmV0dXJuIC1FTk9ERVY7CkBA IC0yMTE4LDEwICsyMTE3LDggQEAgaW50IF9fZ2VuZXJpY19wcm9jZXNzb3JfaW5mbyhpbnQgYXBp Y2lkLCBpbnQgdmVyc2lvbiwgYm9vbCBlbmFibGVkKQogCSAgICBhcGljaWQgIT0gYm9vdF9jcHVf cGh5c2ljYWxfYXBpY2lkKSB7CiAJCWludCB0aGlzY3B1ID0gbWF4ICsgZGlzYWJsZWRfY3B1cyAt IDE7CiAKLQkJcHJfd2FybmluZygKLQkJCSJBUElDOiBOUl9DUFVTL3Bvc3NpYmxlX2NwdXMgbGlt aXQgb2YgJWkgYWxtb3N0IgotCQkJIiByZWFjaGVkLiBLZWVwaW5nIG9uZSBzbG90IGZvciBib290 IGNwdS4iCi0JCQkiICBQcm9jZXNzb3IgJWQvMHgleCBpZ25vcmVkLlxuIiwgbWF4LCB0aGlzY3B1 LCBhcGljaWQpOworCQlwcl93YXJuKCJBUElDOiBOUl9DUFVTL3Bvc3NpYmxlX2NwdXMgbGltaXQg b2YgJWkgYWxtb3N0IHJlYWNoZWQuIEtlZXBpbmcgb25lIHNsb3QgZm9yIGJvb3QgY3B1LiBQcm9j ZXNzb3IgJWQvMHgleCBpZ25vcmVkLlxuIiwKKwkJCW1heCwgdGhpc2NwdSwgYXBpY2lkKTsKIAog CQlkaXNhYmxlZF9jcHVzKys7CiAJCXJldHVybiAtRU5PREVWOwpAQCAtMjEzMSw5ICsyMTI4LDgg QEAgaW50IF9fZ2VuZXJpY19wcm9jZXNzb3JfaW5mbyhpbnQgYXBpY2lkLCBpbnQgdmVyc2lvbiwg Ym9vbCBlbmFibGVkKQogCQlpbnQgdGhpc2NwdSA9IG1heCArIGRpc2FibGVkX2NwdXM7CiAKIAkJ aWYgKGVuYWJsZWQpIHsKLQkJCXByX3dhcm5pbmcoIkFQSUM6IE5SX0NQVVMvcG9zc2libGVfY3B1 cyBsaW1pdCBvZiAlaSAiCi0JCQkJICAgInJlYWNoZWQuIFByb2Nlc3NvciAlZC8weCV4IGlnbm9y ZWQuXG4iLAotCQkJCSAgIG1heCwgdGhpc2NwdSwgYXBpY2lkKTsKKwkJCXByX3dhcm4oIkFQSUM6 IE5SX0NQVVMvcG9zc2libGVfY3B1cyBsaW1pdCBvZiAlaSByZWFjaGVkLiBQcm9jZXNzb3IgJWQv MHgleCBpZ25vcmVkLlxuIiwKKwkJCQltYXgsIHRoaXNjcHUsIGFwaWNpZCk7CiAJCX0KIAogCQlk aXNhYmxlZF9jcHVzKys7CkBAIC0yMTY0LDEzICsyMTYwLDEzIEBAIGludCBfX2dlbmVyaWNfcHJv Y2Vzc29yX2luZm8oaW50IGFwaWNpZCwgaW50IHZlcnNpb24sIGJvb2wgZW5hYmxlZCkKIAkgKiBW YWxpZGF0ZSB2ZXJzaW9uCiAJICovCiAJaWYgKHZlcnNpb24gPT0gMHgwKSB7Ci0JCXByX3dhcm5p bmcoIkJJT1MgYnVnOiBBUElDIHZlcnNpb24gaXMgMCBmb3IgQ1BVICVkLzB4JXgsIGZpeGluZyB1 cCB0byAweDEwXG4iLAotCQkJICAgY3B1LCBhcGljaWQpOworCQlwcl93YXJuKCJCSU9TIGJ1Zzog QVBJQyB2ZXJzaW9uIGlzIDAgZm9yIENQVSAlZC8weCV4LCBmaXhpbmcgdXAgdG8gMHgxMFxuIiwK KwkJCWNwdSwgYXBpY2lkKTsKIAkJdmVyc2lvbiA9IDB4MTA7CiAJfQogCiAJaWYgKHZlcnNpb24g IT0gYm9vdF9jcHVfYXBpY192ZXJzaW9uKSB7Ci0JCXByX3dhcm5pbmcoIkJJT1MgYnVnOiBBUElD IHZlcnNpb24gbWlzbWF0Y2gsIGJvb3QgQ1BVOiAleCwgQ1BVICVkOiB2ZXJzaW9uICV4XG4iLAor CQlwcl93YXJuKCJCSU9TIGJ1ZzogQVBJQyB2ZXJzaW9uIG1pc21hdGNoLCBib290IENQVTogJXgs IENQVSAlZDogdmVyc2lvbiAleFxuIiwKIAkJCWJvb3RfY3B1X2FwaWNfdmVyc2lvbiwgY3B1LCB2 ZXJzaW9uKTsKIAl9CiAKQEAgLTI2MjUsOCArMjYyMSw4IEBAIHN0YXRpYyBpbnQgX19pbml0IGFw aWNfc2V0X3ZlcmJvc2l0eShjaGFyICphcmcpCiAJZWxzZSBpZiAoc3RyY21wKCJ2ZXJib3NlIiwg YXJnKSA9PSAwKQogCQlhcGljX3ZlcmJvc2l0eSA9IEFQSUNfVkVSQk9TRTsKIAllbHNlIHsKLQkJ cHJfd2FybmluZygiQVBJQyBWZXJib3NpdHkgbGV2ZWwgJXMgbm90IHJlY29nbmlzZWQiCi0JCQki IHVzZSBhcGljPXZlcmJvc2Ugb3IgYXBpYz1kZWJ1Z1xuIiwgYXJnKTsKKwkJcHJfd2FybigiQVBJ QyBWZXJib3NpdHkgbGV2ZWwgJXMgbm90IHJlY29nbmlzZWQgdXNlIGFwaWM9dmVyYm9zZSBvciBh cGljPWRlYnVnXG4iLAorCQkJYXJnKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCmRpZmYgLS1n aXQgYS9hcmNoL3g4Ni9rZXJuZWwvYXBpYy9hcGljX25vb3AuYyBiL2FyY2gveDg2L2tlcm5lbC9h cGljL2FwaWNfbm9vcC5jCmluZGV4IGIxMDllNDM4OWM5Mi4uNDdiNmU1YTBiNTc0IDEwMDY0NAot LS0gYS9hcmNoL3g4Ni9rZXJuZWwvYXBpYy9hcGljX25vb3AuYworKysgYi9hcmNoL3g4Ni9rZXJu ZWwvYXBpYy9hcGljX25vb3AuYwpAQCAtOTMsNyArOTMsNyBAQCBzdGF0aWMgdm9pZCBub29wX3Zl Y3Rvcl9hbGxvY2F0aW9uX2RvbWFpbihpbnQgY3B1LCBzdHJ1Y3QgY3B1bWFzayAqcmV0bWFzaywK IAkJCQkJICBjb25zdCBzdHJ1Y3QgY3B1bWFzayAqbWFzaykKIHsKIAlpZiAoY3B1ICE9IDApCi0J CXByX3dhcm5pbmcoIkFQSUM6IFZlY3RvciBhbGxvY2F0ZWQgZm9yIG5vbi1CU1AgY3B1XG4iKTsK KwkJcHJfd2FybigiQVBJQzogVmVjdG9yIGFsbG9jYXRlZCBmb3Igbm9uLUJTUCBjcHVcbiIpOwog CWNwdW1hc2tfY29weShyZXRtYXNrLCBjcHVtYXNrX29mKGNwdSkpOwogfQogCmRpZmYgLS1naXQg YS9hcmNoL3g4Ni9rZXJuZWwvc2V0dXBfcGVyY3B1LmMgYi9hcmNoL3g4Ni9rZXJuZWwvc2V0dXBf cGVyY3B1LmMKaW5kZXggOTgyMGQ2ZDk3N2M2Li5lMDQ1NjJjNDQxMzQgMTAwNjQ0Ci0tLSBhL2Fy Y2gveDg2L2tlcm5lbC9zZXR1cF9wZXJjcHUuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvc2V0dXBf cGVyY3B1LmMKQEAgLTIwNyw4ICsyMDcsOCBAQCB2b2lkIF9faW5pdCBzZXR1cF9wZXJfY3B1X2Fy ZWFzKHZvaWQpCiAJCQkJCSAgICBwY3B1X2NwdV9kaXN0YW5jZSwKIAkJCQkJICAgIHBjcHVfZmNf YWxsb2MsIHBjcHVfZmNfZnJlZSk7CiAJCWlmIChyYyA8IDApCi0JCQlwcl93YXJuaW5nKCIlcyBh bGxvY2F0b3IgZmFpbGVkICglZCksIGZhbGxpbmcgYmFjayB0byBwYWdlIHNpemVcbiIsCi0JCQkJ ICAgcGNwdV9mY19uYW1lc1twY3B1X2Nob3Nlbl9mY10sIHJjKTsKKwkJCXByX3dhcm4oIiVzIGFs bG9jYXRvciBmYWlsZWQgKCVkKSwgZmFsbGluZyBiYWNrIHRvIHBhZ2Ugc2l6ZVxuIiwKKwkJCQlw Y3B1X2ZjX25hbWVzW3BjcHVfY2hvc2VuX2ZjXSwgcmMpOwogCX0KIAlpZiAocmMgPCAwKQogCQly YyA9IHBjcHVfcGFnZV9maXJzdF9jaHVuayhQRVJDUFVfRklSU1RfQ0hVTktfUkVTRVJWRSwKZGlm ZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC90Ym9vdC5jIGIvYXJjaC94ODYva2VybmVsL3Rib290 LmMKaW5kZXggYjg2OGZhMWI4MTJiLi5hNmI1N2Q4ZDBiOWIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2 L2tlcm5lbC90Ym9vdC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC90Ym9vdC5jCkBAIC03MCw3ICs3 MCw3IEBAIHZvaWQgX19pbml0IHRib290X3Byb2JlKHZvaWQpCiAJICovCiAJaWYgKCFlODIwX2Fu eV9tYXBwZWQoYm9vdF9wYXJhbXMudGJvb3RfYWRkciwKIAkJCSAgICAgYm9vdF9wYXJhbXMudGJv b3RfYWRkciwgRTgyMF9SRVNFUlZFRCkpIHsKLQkJcHJfd2FybmluZygibm9uLTAgdGJvb3RfYWRk ciBidXQgaXQgaXMgbm90IG9mIHR5cGUgRTgyMF9SRVNFUlZFRFxuIik7CisJCXByX3dhcm4oIm5v bi0wIHRib290X2FkZHIgYnV0IGl0IGlzIG5vdCBvZiB0eXBlIEU4MjBfUkVTRVJWRURcbiIpOwog CQlyZXR1cm47CiAJfQogCkBAIC03OCwxMyArNzgsMTIgQEAgdm9pZCBfX2luaXQgdGJvb3RfcHJv YmUodm9pZCkKIAlzZXRfZml4bWFwKEZJWF9UQk9PVF9CQVNFLCBib290X3BhcmFtcy50Ym9vdF9h ZGRyKTsKIAl0Ym9vdCA9IChzdHJ1Y3QgdGJvb3QgKilmaXhfdG9fdmlydChGSVhfVEJPT1RfQkFT RSk7CiAJaWYgKG1lbWNtcCgmdGJvb3RfdXVpZCwgJnRib290LT51dWlkLCBzaXplb2YodGJvb3Qt PnV1aWQpKSkgewotCQlwcl93YXJuaW5nKCJ0Ym9vdCBhdCAweCVsbHggaXMgaW52YWxpZFxuIiwK LQkJCSAgIGJvb3RfcGFyYW1zLnRib290X2FkZHIpOworCQlwcl93YXJuKCJ0Ym9vdCBhdCAweCVs bHggaXMgaW52YWxpZFxuIiwgYm9vdF9wYXJhbXMudGJvb3RfYWRkcik7CiAJCXRib290ID0gTlVM TDsKIAkJcmV0dXJuOwogCX0KIAlpZiAodGJvb3QtPnZlcnNpb24gPCA1KSB7Ci0JCXByX3dhcm5p bmcoInRib290IHZlcnNpb24gaXMgaW52YWxpZDogJXVcbiIsIHRib290LT52ZXJzaW9uKTsKKwkJ cHJfd2FybigidGJvb3QgdmVyc2lvbiBpcyBpbnZhbGlkOiAldVxuIiwgdGJvb3QtPnZlcnNpb24p OwogCQl0Ym9vdCA9IE5VTEw7CiAJCXJldHVybjsKIAl9CkBAIC0yODcsNyArMjg2LDcgQEAgc3Rh dGljIGludCB0Ym9vdF9zbGVlcCh1OCBzbGVlcF9zdGF0ZSwgdTMyIHBtMWFfY29udHJvbCwgdTMy IHBtMWJfY29udHJvbCkKIAogCWlmIChzbGVlcF9zdGF0ZSA+PSBBQ1BJX1NfU1RBVEVfQ09VTlQg fHwKIAkgICAgYWNwaV9zaHV0ZG93bl9tYXBbc2xlZXBfc3RhdGVdID09IC0xKSB7Ci0JCXByX3dh cm5pbmcoInVuc3VwcG9ydGVkIHNsZWVwIHN0YXRlIDB4JXhcbiIsIHNsZWVwX3N0YXRlKTsKKwkJ cHJfd2FybigidW5zdXBwb3J0ZWQgc2xlZXAgc3RhdGUgMHgleFxuIiwgc2xlZXBfc3RhdGUpOwog CQlyZXR1cm4gLTE7CiAJfQogCkBAIC0zMDAsNyArMjk5LDcgQEAgc3RhdGljIGludCB0Ym9vdF9l eHRlbmRlZF9zbGVlcCh1OCBzbGVlcF9zdGF0ZSwgdTMyIHZhbF9hLCB1MzIgdmFsX2IpCiAJaWYg KCF0Ym9vdF9lbmFibGVkKCkpCiAJCXJldHVybiAwOwogCi0JcHJfd2FybmluZygidGJvb3QgaXMg bm90IGFibGUgdG8gc3VzcGVuZCBvbiBwbGF0Zm9ybXMgd2l0aCByZWR1Y2VkIGhhcmR3YXJlIHNs ZWVwIChBQ1BJdjUpIik7CisJcHJfd2FybigidGJvb3QgaXMgbm90IGFibGUgdG8gc3VzcGVuZCBv biBwbGF0Zm9ybXMgd2l0aCByZWR1Y2VkIGhhcmR3YXJlIHNsZWVwIChBQ1BJdjUpXG4iKTsKIAly ZXR1cm4gLUVOT0RFVjsKIH0KIApAQCAtMzE4LDcgKzMxNyw3IEBAIHN0YXRpYyBpbnQgdGJvb3Rf d2FpdF9mb3JfYXBzKGludCBudW1fYXBzKQogCX0KIAogCWlmICh0aW1lb3V0KQotCQlwcl93YXJu aW5nKCJ0Ym9vdCB3YWl0IGZvciBBUHMgdGltZW91dFxuIik7CisJCXByX3dhcm4oInRib290IHdh aXQgZm9yIEFQcyB0aW1lb3V0XG4iKTsKIAogCXJldHVybiAhKGF0b21pY19yZWFkKChhdG9taWNf dCAqKSZ0Ym9vdC0+bnVtX2luX3dmcykgPT0gbnVtX2Fwcyk7CiB9CkBAIC01MTEsNyArNTEwLDcg QEAgaW50IHRib290X2ZvcmNlX2lvbW11KHZvaWQpCiAJCXJldHVybiAwOwogCiAJaWYgKG5vX2lv bW11IHx8IHN3aW90bGIgfHwgZG1hcl9kaXNhYmxlZCkKLQkJcHJfd2FybmluZygiRm9yY2luZyBJ bnRlbC1JT01NVSB0byBlbmFibGVkXG4iKTsKKwkJcHJfd2FybigiRm9yY2luZyBJbnRlbC1JT01N VSB0byBlbmFibGVkXG4iKTsKIAogCWRtYXJfZGlzYWJsZWQgPSAwOwogI2lmZGVmIENPTkZJR19T V0lPVExCCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvdHNjX3N5bmMuYyBiL2FyY2gveDg2 L2tlcm5lbC90c2Nfc3luYy5jCmluZGV4IDcyOGY3NTM3ODQ3NS4uNjFkZTRmYmY4ZjQ1IDEwMDY0 NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvdHNjX3N5bmMuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwv dHNjX3N5bmMuYwpAQCAtMzMyLDEyICszMzIsMTIgQEAgdm9pZCBjaGVja190c2Nfc3luY19zb3Vy Y2UoaW50IGNwdSkKIAkJLyogRm9yY2UgaXQgdG8gMCBpZiByYW5kb20gd2FycHMgYnJvdWdodCB1 cyBoZXJlICovCiAJCWF0b21pY19zZXQoJnRlc3RfcnVucywgMCk7CiAKLQkJcHJfd2FybmluZygi VFNDIHN5bmNocm9uaXphdGlvbiBbQ1BVIyVkIC0+IENQVSMlZF06XG4iLAorCQlwcl93YXJuKCJU U0Mgc3luY2hyb25pemF0aW9uIFtDUFUjJWQgLT4gQ1BVIyVkXTpcbiIsCiAJCQlzbXBfcHJvY2Vz c29yX2lkKCksIGNwdSk7Ci0JCXByX3dhcm5pbmcoIk1lYXN1cmVkICVMZCBjeWNsZXMgVFNDIHdh cnAgYmV0d2VlbiBDUFVzLCAiCi0JCQkgICAidHVybmluZyBvZmYgVFNDIGNsb2NrLlxuIiwgbWF4 X3dhcnApOworCQlwcl93YXJuKCJNZWFzdXJlZCAlbGxkIGN5Y2xlcyBUU0Mgd2FycCBiZXR3ZWVu IENQVXMsIHR1cm5pbmcgb2ZmIFRTQyBjbG9ja1xuIiwKKwkJCW1heF93YXJwKTsKIAkJaWYgKHJh bmRvbV93YXJwcykKLQkJCXByX3dhcm5pbmcoIlRTQyB3YXJwZWQgcmFuZG9tbHkgYmV0d2VlbiBD UFVzXG4iKTsKKwkJCXByX3dhcm4oIlRTQyB3YXJwZWQgcmFuZG9tbHkgYmV0d2VlbiBDUFVzXG4i KTsKIAkJbWFya190c2NfdW5zdGFibGUoImNoZWNrX3RzY19zeW5jX3NvdXJjZSBmYWlsZWQiKTsK IAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL2ttbWlvLmMgYi9hcmNoL3g4Ni9tbS9rbW1p by5jCmluZGV4IGFmYzQ3ZjVjOTUzMS4uYWQ3MDUxOGNkY2M3IDEwMDY0NAotLS0gYS9hcmNoL3g4 Ni9tbS9rbW1pby5jCisrKyBiL2FyY2gveDg2L21tL2ttbWlvLmMKQEAgLTE4Nyw4ICsxODcsOCBA QCBzdGF0aWMgaW50IGFybV9rbW1pb19mYXVsdF9wYWdlKHN0cnVjdCBrbW1pb19mYXVsdF9wYWdl ICpmKQogCWludCByZXQ7CiAJV0FSTl9PTkNFKGYtPmFybWVkLCBLRVJOX0VSUiBwcl9mbXQoImtt bWlvIHBhZ2UgYWxyZWFkeSBhcm1lZC5cbiIpKTsKIAlpZiAoZi0+YXJtZWQpIHsKLQkJcHJfd2Fy bmluZygiZG91YmxlLWFybTogYWRkciAweCUwOGx4LCByZWYgJWQsIG9sZCAlZFxuIiwKLQkJCSAg IGYtPmFkZHIsIGYtPmNvdW50LCAhIWYtPm9sZF9wcmVzZW5jZSk7CisJCXByX3dhcm4oImRvdWJs ZS1hcm06IGFkZHIgMHglMDhseCwgcmVmICVkLCBvbGQgJWRcbiIsCisJCQlmLT5hZGRyLCBmLT5j b3VudCwgISFmLT5vbGRfcHJlc2VuY2UpOwogCX0KIAlyZXQgPSBjbGVhcl9wYWdlX3ByZXNlbmNl KGYsIHRydWUpOwogCVdBUk5fT05DRShyZXQgPCAwLCBLRVJOX0VSUiBwcl9mbXQoImFybWluZyBh dCAweCUwOGx4IGZhaWxlZC5cbiIpLApAQCAtMzM1LDggKzMzNSw4IEBAIHN0YXRpYyBpbnQgcG9z dF9rbW1pb19oYW5kbGVyKHVuc2lnbmVkIGxvbmcgY29uZGl0aW9uLCBzdHJ1Y3QgcHRfcmVncyAq cmVncykKIAkJICogc29tZXRoaW5nIGV4dGVybmFsIGNhdXNpbmcgdGhlbSAoZi5lLiB1c2luZyBh IGRlYnVnZ2VyIHdoaWxlCiAJCSAqIG1taW8gdHJhY2luZyBlbmFibGVkKSwgb3IgZXJyb25lb3Vz IGJlaGF2aW91cgogCQkgKi8KLQkJcHJfd2FybmluZygidW5leHBlY3RlZCBkZWJ1ZyB0cmFwIG9u IENQVSAlZC5cbiIsCi0JCQkgICBzbXBfcHJvY2Vzc29yX2lkKCkpOworCQlwcl93YXJuKCJ1bmV4 cGVjdGVkIGRlYnVnIHRyYXAgb24gQ1BVICVkXG4iLAorCQkJc21wX3Byb2Nlc3Nvcl9pZCgpKTsK IAkJZ290byBvdXQ7CiAJfQogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9tbS9tbWlvLW1vZC5jIGIv YXJjaC94ODYvbW0vbW1pby1tb2QuYwppbmRleCBiZWYzNjYyMmU0MDguLjcwNmFlNDRkMWFmNyAx MDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vbW1pby1tb2QuYworKysgYi9hcmNoL3g4Ni9tbS9tbWlv LW1vZC5jCkBAIC00MDcsNyArNDA3LDcgQEAgc3RhdGljIHZvaWQgZW50ZXJfdW5pcHJvY2Vzc29y KHZvaWQpCiAJfQogb3V0OgogCWlmIChudW1fb25saW5lX2NwdXMoKSA+IDEpCi0JCXByX3dhcm5p bmcoIm11bHRpcGxlIENQVXMgc3RpbGwgb25saW5lLCBtYXkgbWlzcyBldmVudHMuXG4iKTsKKwkJ cHJfd2FybigibXVsdGlwbGUgQ1BVcyBzdGlsbCBvbmxpbmUsIG1heSBtaXNzIGV2ZW50c1xuIik7 CiB9CiAKIHN0YXRpYyB2b2lkIGxlYXZlX3VuaXByb2Nlc3Nvcih2b2lkKQpAQCAtNDMxLDggKzQz MSw3IEBAIHN0YXRpYyB2b2lkIGxlYXZlX3VuaXByb2Nlc3Nvcih2b2lkKQogc3RhdGljIHZvaWQg ZW50ZXJfdW5pcHJvY2Vzc29yKHZvaWQpCiB7CiAJaWYgKG51bV9vbmxpbmVfY3B1cygpID4gMSkK LQkJcHJfd2FybmluZygibXVsdGlwbGUgQ1BVcyBhcmUgb25saW5lLCBtYXkgbWlzcyBldmVudHMu ICIKLQkJCSAgICJTdWdnZXN0IGJvb3Rpbmcgd2l0aCBtYXhjcHVzPTEga2VybmVsIGFyZ3VtZW50 LlxuIik7CisJCXByX3dhcm4oIm11bHRpcGxlIENQVXMgYXJlIG9ubGluZSwgbWF5IG1pc3MgZXZl bnRzLiBTdWdnZXN0IGJvb3Rpbmcgd2l0aCBtYXhjcHVzPTEga2VybmVsIGFyZ3VtZW50LlxuIik7 CiB9CiAKIHN0YXRpYyB2b2lkIGxlYXZlX3VuaXByb2Nlc3Nvcih2b2lkKQpkaWZmIC0tZ2l0IGEv YXJjaC94ODYvbW0vbnVtYS5jIGIvYXJjaC94ODYvbW0vbnVtYS5jCmluZGV4IDEyZGNhZDcyOTdh NS4uM2FhMjM2ZjBhMmZiIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9tbS9udW1hLmMKKysrIGIvYXJj aC94ODYvbW0vbnVtYS5jCkBAIC0xMzYsOCArMTM2LDggQEAgc3RhdGljIGludCBfX2luaXQgbnVt YV9hZGRfbWVtYmxrX3RvKGludCBuaWQsIHU2NCBzdGFydCwgdTY0IGVuZCwKIAogCS8qIHdoaW5l IGFib3V0IGFuZCBpZ25vcmUgaW52YWxpZCBibGtzICovCiAJaWYgKHN0YXJ0ID4gZW5kIHx8IG5p ZCA8IDAgfHwgbmlkID49IE1BWF9OVU1OT0RFUykgewotCQlwcl93YXJuaW5nKCJOVU1BOiBXYXJu aW5nOiBpbnZhbGlkIG1lbWJsayBub2RlICVkIFttZW0gJSMwMTBMeC0lIzAxMEx4XVxuIiwKLQkJ CSAgIG5pZCwgc3RhcnQsIGVuZCAtIDEpOworCQlwcl93YXJuKCJOVU1BOiBXYXJuaW5nOiBpbnZh bGlkIG1lbWJsayBub2RlICVkIFttZW0gJSMwMTBMeC0lIzAxMEx4XVxuIiwKKwkJCW5pZCwgc3Rh cnQsIGVuZCAtIDEpOwogCQlyZXR1cm4gMDsKIAl9CiAKQEAgLTI3Miw5ICsyNzIsOSBAQCBpbnQg X19pbml0IG51bWFfY2xlYW51cF9tZW1pbmZvKHN0cnVjdCBudW1hX21lbWluZm8gKm1pKQogCQkJ CQkgICAgICAgYmotPm5pZCwgYmotPnN0YXJ0LCBiai0+ZW5kIC0gMSk7CiAJCQkJCXJldHVybiAt RUlOVkFMOwogCQkJCX0KLQkJCQlwcl93YXJuaW5nKCJOVU1BOiBXYXJuaW5nOiBub2RlICVkIFtt ZW0gJSMwMTBMeC0lIzAxMEx4XSBvdmVybGFwcyB3aXRoIGl0c2VsZiBbbWVtICUjMDEwTHgtJSMw MTBMeF1cbiIsCi0JCQkJCSAgIGJpLT5uaWQsIGJpLT5zdGFydCwgYmktPmVuZCAtIDEsCi0JCQkJ CSAgIGJqLT5zdGFydCwgYmotPmVuZCAtIDEpOworCQkJCXByX3dhcm4oIk5VTUE6IFdhcm5pbmc6 IG5vZGUgJWQgW21lbSAlIzAxMEx4LSUjMDEwTHhdIG92ZXJsYXBzIHdpdGggaXRzZWxmIFttZW0g JSMwMTBMeC0lIzAxMEx4XVxuIiwKKwkJCQkJYmktPm5pZCwgYmktPnN0YXJ0LCBiaS0+ZW5kIC0g MSwKKwkJCQkJYmotPnN0YXJ0LCBiai0+ZW5kIC0gMSk7CiAJCQl9CiAKIAkJCS8qCkBAIC0zNjQs NyArMzY0LDcgQEAgc3RhdGljIGludCBfX2luaXQgbnVtYV9hbGxvY19kaXN0YW5jZSh2b2lkKQog CXBoeXMgPSBtZW1ibG9ja19maW5kX2luX3JhbmdlKDAsIFBGTl9QSFlTKG1heF9wZm5fbWFwcGVk KSwKIAkJCQkgICAgICBzaXplLCBQQUdFX1NJWkUpOwogCWlmICghcGh5cykgewotCQlwcl93YXJu aW5nKCJOVU1BOiBXYXJuaW5nOiBjYW4ndCBhbGxvY2F0ZSBkaXN0YW5jZSB0YWJsZSFcbiIpOwor CQlwcl93YXJuKCJOVU1BOiBXYXJuaW5nOiBjYW4ndCBhbGxvY2F0ZSBkaXN0YW5jZSB0YWJsZSFc biIpOwogCQkvKiBkb24ndCByZXRyeSB1bnRpbCBleHBsaWNpdGx5IHJlc2V0ICovCiAJCW51bWFf ZGlzdGFuY2UgPSAodm9pZCAqKTFMVTsKIAkJcmV0dXJuIC1FTk9NRU07CmRpZmYgLS1naXQgYS9h cmNoL3g4Ni9tbS9udW1hX2VtdWxhdGlvbi5jIGIvYXJjaC94ODYvbW0vbnVtYV9lbXVsYXRpb24u YwppbmRleCBhOGY5MGNlM2RlZGYuLmE2NDQ2YWQzY2QzMiAxMDA2NDQKLS0tIGEvYXJjaC94ODYv bW0vbnVtYV9lbXVsYXRpb24uYworKysgYi9hcmNoL3g4Ni9tbS9udW1hX2VtdWxhdGlvbi5jCkBA IC0zNDksNyArMzQ5LDcgQEAgdm9pZCBfX2luaXQgbnVtYV9lbXVsYXRpb24oc3RydWN0IG51bWFf bWVtaW5mbyAqbnVtYV9tZW1pbmZvLCBpbnQgbnVtYV9kaXN0X2NudCkKIAkJZ290byBub19lbXU7 CiAKIAlpZiAobnVtYV9jbGVhbnVwX21lbWluZm8oJmVpKSA8IDApIHsKLQkJcHJfd2FybmluZygi TlVNQTogV2FybmluZzogY29uc3RydWN0ZWQgbWVtaW5mbyBpbnZhbGlkLCBkaXNhYmxpbmcgZW11 bGF0aW9uXG4iKTsKKwkJcHJfd2FybigiTlVNQTogV2FybmluZzogY29uc3RydWN0ZWQgbWVtaW5m byBpbnZhbGlkLCBkaXNhYmxpbmcgZW11bGF0aW9uXG4iKTsKIAkJZ290byBub19lbXU7CiAJfQog CkBAIC0zNjAsNyArMzYwLDcgQEAgdm9pZCBfX2luaXQgbnVtYV9lbXVsYXRpb24oc3RydWN0IG51 bWFfbWVtaW5mbyAqbnVtYV9tZW1pbmZvLCBpbnQgbnVtYV9kaXN0X2NudCkKIAkJcGh5cyA9IG1l bWJsb2NrX2ZpbmRfaW5fcmFuZ2UoMCwgUEZOX1BIWVMobWF4X3Bmbl9tYXBwZWQpLAogCQkJCQkg ICAgICBwaHlzX3NpemUsIFBBR0VfU0laRSk7CiAJCWlmICghcGh5cykgewotCQkJcHJfd2Fybmlu ZygiTlVNQTogV2FybmluZzogY2FuJ3QgYWxsb2NhdGUgY29weSBvZiBkaXN0YW5jZSB0YWJsZSwg ZGlzYWJsaW5nIGVtdWxhdGlvblxuIik7CisJCQlwcl93YXJuKCJOVU1BOiBXYXJuaW5nOiBjYW4n dCBhbGxvY2F0ZSBjb3B5IG9mIGRpc3RhbmNlIHRhYmxlLCBkaXNhYmxpbmcgZW11bGF0aW9uXG4i KTsKIAkJCWdvdG8gbm9fZW11OwogCQl9CiAJCW1lbWJsb2NrX3Jlc2VydmUocGh5cywgcGh5c19z aXplKTsKQEAgLTM4Niw3ICszODYsNyBAQCB2b2lkIF9faW5pdCBudW1hX2VtdWxhdGlvbihzdHJ1 Y3QgbnVtYV9tZW1pbmZvICpudW1hX21lbWluZm8sIGludCBudW1hX2Rpc3RfY250KQogCQl9CiAJ fQogCWlmIChkZmxfcGh5c19uaWQgPT0gTlVNQV9OT19OT0RFKSB7Ci0JCXByX3dhcm5pbmcoIk5V TUE6IFdhcm5pbmc6IGNhbid0IGRldGVybWluZSBkZWZhdWx0IHBoeXNpY2FsIG5vZGUsIGRpc2Fi bGluZyBlbXVsYXRpb25cbiIpOworCQlwcl93YXJuKCJOVU1BOiBXYXJuaW5nOiBjYW4ndCBkZXRl cm1pbmUgZGVmYXVsdCBwaHlzaWNhbCBub2RlLCBkaXNhYmxpbmcgZW11bGF0aW9uXG4iKTsKIAkJ Z290byBub19lbXU7CiAJfQogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9tbS90ZXN0bW1pb3RyYWNl LmMgYi9hcmNoL3g4Ni9tbS90ZXN0bW1pb3RyYWNlLmMKaW5kZXggMzg4NjhhZGYwN2VhLi40YTU1 ZTQ1MzI5NmQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L21tL3Rlc3RtbWlvdHJhY2UuYworKysgYi9h cmNoL3g4Ni9tbS90ZXN0bW1pb3RyYWNlLmMKQEAgLTEyMSw5ICsxMjEsOCBAQCBzdGF0aWMgaW50 IF9faW5pdCBpbml0KHZvaWQpCiAJCXJldHVybiAtRU5YSU87CiAJfQogCi0JcHJfd2FybmluZygi V0FSTklORzogbWFwcGluZyAlbHUga0IgQCAweCUwOGx4IGluIFBDSSBhZGRyZXNzIHNwYWNlLCAi Ci0JCSAgICJhbmQgd3JpdGluZyAxNiBrQiBvZiBydWJiaXNoIGluIHRoZXJlLlxuIiwKLQkJICAg c2l6ZSA+PiAxMCwgbW1pb19hZGRyZXNzKTsKKwlwcl93YXJuKCJXQVJOSU5HOiBtYXBwaW5nICVs dSBrQiBAIDB4JTA4bHggaW4gUENJIGFkZHJlc3Mgc3BhY2UsIGFuZCB3cml0aW5nIDE2IGtCIG9m IHJ1YmJpc2ggaW4gdGhlcmVcbiIsCisJCXNpemUgPj4gMTAsIG1taW9fYWRkcmVzcyk7CiAJZG9f dGVzdChzaXplKTsKIAlkb190ZXN0X2J1bGtfaW9yZW1hcHBpbmcoKTsKIAlwcl9pbmZvKCJBbGwg ZG9uZS5cbiIpOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvb3Byb2ZpbGUvb3BfeDg2X21vZGVsLmgg Yi9hcmNoL3g4Ni9vcHJvZmlsZS9vcF94ODZfbW9kZWwuaAppbmRleCA3MWU4YTY3MzM3ZTIuLjI3 NmNmNzliNWQyNCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvb3Byb2ZpbGUvb3BfeDg2X21vZGVsLmgK KysrIGIvYXJjaC94ODYvb3Byb2ZpbGUvb3BfeDg2X21vZGVsLmgKQEAgLTY3LDEzICs2NywxMyBA QCBzdGF0aWMgaW5saW5lIHZvaWQgb3BfeDg2X3dhcm5faW5fdXNlKGludCBjb3VudGVyKQogCSAq IGNhbm5vdCBiZSBtb25pdG9yZWQgYnkgYW55IG90aGVyIGNvdW50ZXIsIGNvbnRhY3QgeW91cgog CSAqIGhhcmR3YXJlIG9yIEJJT1MgdmVuZG9yLgogCSAqLwotCXByX3dhcm5pbmcoIm9wcm9maWxl OiBjb3VudGVyICMlZCBvbiBjcHUgIyVkIG1heSBhbHJlYWR5IGJlIHVzZWRcbiIsCi0JCSAgIGNv dW50ZXIsIHNtcF9wcm9jZXNzb3JfaWQoKSk7CisJcHJfd2Fybigib3Byb2ZpbGU6IGNvdW50ZXIg IyVkIG9uIGNwdSAjJWQgbWF5IGFscmVhZHkgYmUgdXNlZFxuIiwKKwkJY291bnRlciwgc21wX3By b2Nlc3Nvcl9pZCgpKTsKIH0KIAogc3RhdGljIGlubGluZSB2b2lkIG9wX3g4Nl93YXJuX3Jlc2Vy dmVkKGludCBjb3VudGVyKQogewotCXByX3dhcm5pbmcoIm9wcm9maWxlOiBjb3VudGVyICMlZCBp cyBhbHJlYWR5IHJlc2VydmVkXG4iLCBjb3VudGVyKTsKKwlwcl93YXJuKCJvcHJvZmlsZTogY291 bnRlciAjJWQgaXMgYWxyZWFkeSByZXNlcnZlZFxuIiwgY291bnRlcik7CiB9CiAKIGV4dGVybiB1 NjQgb3BfeDg2X2dldF9jdHJsKHN0cnVjdCBvcF94ODZfbW9kZWxfc3BlYyBjb25zdCAqbW9kZWws CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9wbGF0Zm9ybS9vbHBjL29scGMteG8xNS1zY2kuYyBiL2Fy Y2gveDg2L3BsYXRmb3JtL29scGMvb2xwYy14bzE1LXNjaS5jCmluZGV4IGMwNTMzZmJjMzllMy4u ZTQ2YzczYmEzYjQ0IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wbGF0Zm9ybS9vbHBjL29scGMteG8x NS1zY2kuYworKysgYi9hcmNoL3g4Ni9wbGF0Zm9ybS9vbHBjL29scGMteG8xNS1zY2kuYwpAQCAt NDMsNyArNDMsNyBAQCBzdGF0aWMgaW50IHNldF9saWRfd2FrZV9iZWhhdmlvcihib29sIHdha2Vf b25fY2xvc2UpCiAKIAlzdGF0dXMgPSBhY3BpX2V4ZWN1dGVfc2ltcGxlX21ldGhvZChOVUxMLCAi XFxfU0IuUENJMC5MSUQuTElEVyIsIHdha2Vfb25fY2xvc2UpOwogCWlmIChBQ1BJX0ZBSUxVUkUo c3RhdHVzKSkgewotCQlwcl93YXJuaW5nKFBGWCAiZmFpbGVkIHRvIHNldCBsaWQgYmVoYXZpb3Jc biIpOworCQlwcl93YXJuKFBGWCAiZmFpbGVkIHRvIHNldCBsaWQgYmVoYXZpb3JcbiIpOwogCQly ZXR1cm4gMTsKIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3BsYXRmb3JtL3NmaS9zZmkuYyBi L2FyY2gveDg2L3BsYXRmb3JtL3NmaS9zZmkuYwppbmRleCA2YzcxMTFiYmQxZTkuLjUzMDY1NWU4 NDA1ZSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvcGxhdGZvcm0vc2ZpL3NmaS5jCisrKyBiL2FyY2gv eDg2L3BsYXRmb3JtL3NmaS9zZmkuYwpAQCAtMzksOCArMzksNyBAQCBzdGF0aWMgdW5zaWduZWQg bG9uZyBzZmlfbGFwaWNfYWRkciBfX2luaXRkYXRhID0gQVBJQ19ERUZBVUxUX1BIWVNfQkFTRTsK IHN0YXRpYyB2b2lkIF9faW5pdCBtcF9zZmlfcmVnaXN0ZXJfbGFwaWModTggaWQpCiB7CiAJaWYg KE1BWF9MT0NBTF9BUElDIC0gaWQgPD0gMCkgewotCQlwcl93YXJuaW5nKCJQcm9jZXNzb3IgIyVk IGludmFsaWQgKG1heCAlZClcbiIsCi0JCQlpZCwgTUFYX0xPQ0FMX0FQSUMpOworCQlwcl93YXJu KCJQcm9jZXNzb3IgIyVkIGludmFsaWQgKG1heCAlZClcbiIsIGlkLCBNQVhfTE9DQUxfQVBJQyk7 CiAJCXJldHVybjsKIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hlbi9kZWJ1Z2ZzLmMgYi9h cmNoL3g4Ni94ZW4vZGVidWdmcy5jCmluZGV4IDFkYWZmNTU0NWMwYS4uMzU4ZjkyZGE4ZDllIDEw MDY0NAotLS0gYS9hcmNoL3g4Ni94ZW4vZGVidWdmcy5jCisrKyBiL2FyY2gveDg2L3hlbi9kZWJ1 Z2ZzLmMKQEAgLTEyLDcgKzEyLDcgQEAgc3RydWN0IGRlbnRyeSAqIF9faW5pdCB4ZW5faW5pdF9k ZWJ1Z2ZzKHZvaWQpCiAJCWRfeGVuX2RlYnVnID0gZGVidWdmc19jcmVhdGVfZGlyKCJ4ZW4iLCBO VUxMKTsKIAogCQlpZiAoIWRfeGVuX2RlYnVnKQotCQkJcHJfd2FybmluZygiQ291bGQgbm90IGNy ZWF0ZSAneGVuJyBkZWJ1Z2ZzIGRpcmVjdG9yeVxuIik7CisJCQlwcl93YXJuKCJDb3VsZCBub3Qg Y3JlYXRlICd4ZW4nIGRlYnVnZnMgZGlyZWN0b3J5XG4iKTsKIAl9CiAKIAlyZXR1cm4gZF94ZW5f ZGVidWc7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vc2V0dXAuYyBiL2FyY2gveDg2L3hlbi9z ZXR1cC5jCmluZGV4IGE4YzMwNmNmODg2OC4uYjkyZTkyNGI5NDY0IDEwMDY0NAotLS0gYS9hcmNo L3g4Ni94ZW4vc2V0dXAuYworKysgYi9hcmNoL3g4Ni94ZW4vc2V0dXAuYwpAQCAtNDEzLDcgKzQx Myw3IEBAIHN0YXRpYyB1bnNpZ25lZCBsb25nIF9faW5pdCB4ZW5fc2V0X2lkZW50aXR5X2FuZF9y ZW1hcF9jaHVuaygKIAogCQlyZW1hcF9yYW5nZV9zaXplID0geGVuX2ZpbmRfcGZuX3JhbmdlKCZy ZW1hcF9wZm4pOwogCQlpZiAoIXJlbWFwX3JhbmdlX3NpemUpIHsKLQkJCXByX3dhcm5pbmcoIlVu YWJsZSB0byBmaW5kIGF2YWlsYWJsZSBwZm4gcmFuZ2UsIG5vdCByZW1hcHBpbmcgaWRlbnRpdHkg cGFnZXNcbiIpOworCQkJcHJfd2FybigiVW5hYmxlIHRvIGZpbmQgYXZhaWxhYmxlIHBmbiByYW5n ZSwgbm90IHJlbWFwcGluZyBpZGVudGl0eSBwYWdlc1xuIik7CiAJCQl4ZW5fc2V0X2lkZW50aXR5 X2FuZF9yZWxlYXNlX2NodW5rKGN1cl9wZm4sCiAJCQkJCQljdXJfcGZuICsgbGVmdCwgbnJfcGFn ZXMpOwogCQkJYnJlYWs7Ci0tIAoyLjEwLjAucmMyLjEuZzA1MzQzNWMKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0 Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK