Merge branch 'stable/bug.fixes' of git://oss.oracle.com/git/kwilk/xen

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

* 'stable/bug.fixes' of git://oss.oracle.com/git/kwilk/xen:
xen/i386: follow-up to "replace order-based range checking of M2P table by linear one"
xen/irq: Alter the locking to use a mutex instead of a spinlock.
xen/e820: if there is no dom0_mem=, don't tweak extra_pages.
xen: disable PV spinlocks on HVM

Linus Torvalds 14 years ago abbe0d3c c455ea4f

+28 -29

4 changed files

expand all

arch

x86

xen

mmu.c

setup.c

smp.c

drivers

xen

events.c

+2 -4

arch/x86/xen/mmu.c

··· 1721 1721 machine_to_phys_nr = MACH2PHYS_NR_ENTRIES; 1722 1722 } 1723 1723 #ifdef CONFIG_X86_32 1724 - if ((machine_to_phys_mapping + machine_to_phys_nr) 1725 - < machine_to_phys_mapping) 1726 - machine_to_phys_nr = (unsigned long *)NULL 1727 - - machine_to_phys_mapping; 1724 + WARN_ON((machine_to_phys_mapping + (machine_to_phys_nr - 1)) 1725 + < machine_to_phys_mapping); 1728 1726 #endif 1729 1727 } 1730 1728

+6 -4

arch/x86/xen/setup.c

··· 306 306 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); 307 307 308 308 extra_limit = xen_get_max_pages(); 309 - if (extra_limit >= max_pfn) 310 - extra_pages = extra_limit - max_pfn; 311 - else 312 - extra_pages = 0; 309 + if (max_pfn + extra_pages > extra_limit) { 310 + if (extra_limit > max_pfn) 311 + extra_pages = extra_limit - max_pfn; 312 + else 313 + extra_pages = 0; 314 + } 313 315 314 316 extra_pages += xen_return_unused_memory(xen_start_info->nr_pages, &e820); 315 317

-1

arch/x86/xen/smp.c

··· 532 532 WARN_ON(xen_smp_intr_init(0)); 533 533 534 534 xen_init_lock_cpu(0); 535 - xen_init_spinlocks(); 536 535 } 537 536 538 537 static int __cpuinit xen_hvm_cpu_up(unsigned int cpu)

+20 -20

drivers/xen/events.c

··· 54 54 * This lock protects updates to the following mapping and reference-count 55 55 * arrays. The lock does not need to be acquired to read the mapping tables. 56 56 */ 57 - static DEFINE_SPINLOCK(irq_mapping_update_lock); 57 + static DEFINE_MUTEX(irq_mapping_update_lock); 58 58 59 59 static LIST_HEAD(xen_irq_list_head); 60 60 ··· 631 631 int irq = -1; 632 632 struct physdev_irq irq_op; 633 633 634 - spin_lock(&irq_mapping_update_lock); 634 + mutex_lock(&irq_mapping_update_lock); 635 635 636 636 irq = find_irq_by_gsi(gsi); 637 637 if (irq != -1) { ··· 684 684 handle_edge_irq, name); 685 685 686 686 out: 687 - spin_unlock(&irq_mapping_update_lock); 687 + mutex_unlock(&irq_mapping_update_lock); 688 688 689 689 return irq; 690 690 } ··· 710 710 { 711 711 int irq, ret; 712 712 713 - spin_lock(&irq_mapping_update_lock); 713 + mutex_lock(&irq_mapping_update_lock); 714 714 715 715 irq = xen_allocate_irq_dynamic(); 716 716 if (irq == -1) ··· 724 724 if (ret < 0) 725 725 goto error_irq; 726 726 out: 727 - spin_unlock(&irq_mapping_update_lock); 727 + mutex_unlock(&irq_mapping_update_lock); 728 728 return irq; 729 729 error_irq: 730 - spin_unlock(&irq_mapping_update_lock); 730 + mutex_unlock(&irq_mapping_update_lock); 731 731 xen_free_irq(irq); 732 732 return -1; 733 733 } ··· 740 740 struct irq_info *info = info_for_irq(irq); 741 741 int rc = -ENOENT; 742 742 743 - spin_lock(&irq_mapping_update_lock); 743 + mutex_lock(&irq_mapping_update_lock); 744 744 745 745 desc = irq_to_desc(irq); 746 746 if (!desc) ··· 766 766 xen_free_irq(irq); 767 767 768 768 out: 769 - spin_unlock(&irq_mapping_update_lock); 769 + mutex_unlock(&irq_mapping_update_lock); 770 770 return rc; 771 771 } 772 772 ··· 776 776 777 777 struct irq_info *info; 778 778 779 - spin_lock(&irq_mapping_update_lock); 779 + mutex_lock(&irq_mapping_update_lock); 780 780 781 781 list_for_each_entry(info, &xen_irq_list_head, list) { 782 782 if (info == NULL || info->type != IRQT_PIRQ) ··· 787 787 } 788 788 irq = -1; 789 789 out: 790 - spin_unlock(&irq_mapping_update_lock); 790 + mutex_unlock(&irq_mapping_update_lock); 791 791 792 792 return irq; 793 793 } ··· 802 802 { 803 803 int irq; 804 804 805 - spin_lock(&irq_mapping_update_lock); 805 + mutex_lock(&irq_mapping_update_lock); 806 806 807 807 irq = evtchn_to_irq[evtchn]; 808 808 ··· 818 818 } 819 819 820 820 out: 821 - spin_unlock(&irq_mapping_update_lock); 821 + mutex_unlock(&irq_mapping_update_lock); 822 822 823 823 return irq; 824 824 } ··· 829 829 struct evtchn_bind_ipi bind_ipi; 830 830 int evtchn, irq; 831 831 832 - spin_lock(&irq_mapping_update_lock); 832 + mutex_lock(&irq_mapping_update_lock); 833 833 834 834 irq = per_cpu(ipi_to_irq, cpu)[ipi]; 835 835 ··· 853 853 } 854 854 855 855 out: 856 - spin_unlock(&irq_mapping_update_lock); 856 + mutex_unlock(&irq_mapping_update_lock); 857 857 return irq; 858 858 } 859 859 ··· 878 878 struct evtchn_bind_virq bind_virq; 879 879 int evtchn, irq; 880 880 881 - spin_lock(&irq_mapping_update_lock); 881 + mutex_lock(&irq_mapping_update_lock); 882 882 883 883 irq = per_cpu(virq_to_irq, cpu)[virq]; 884 884 ··· 903 903 } 904 904 905 905 out: 906 - spin_unlock(&irq_mapping_update_lock); 906 + mutex_unlock(&irq_mapping_update_lock); 907 907 908 908 return irq; 909 909 } ··· 913 913 struct evtchn_close close; 914 914 int evtchn = evtchn_from_irq(irq); 915 915 916 - spin_lock(&irq_mapping_update_lock); 916 + mutex_lock(&irq_mapping_update_lock); 917 917 918 918 if (VALID_EVTCHN(evtchn)) { 919 919 close.port = evtchn; ··· 943 943 944 944 xen_free_irq(irq); 945 945 946 - spin_unlock(&irq_mapping_update_lock); 946 + mutex_unlock(&irq_mapping_update_lock); 947 947 } 948 948 949 949 int bind_evtchn_to_irqhandler(unsigned int evtchn, ··· 1279 1279 will also be masked. */ 1280 1280 disable_irq(irq); 1281 1281 1282 - spin_lock(&irq_mapping_update_lock); 1282 + mutex_lock(&irq_mapping_update_lock); 1283 1283 1284 1284 /* After resume the irq<->evtchn mappings are all cleared out */ 1285 1285 BUG_ON(evtchn_to_irq[evtchn] != -1); ··· 1289 1289 1290 1290 xen_irq_info_evtchn_init(irq, evtchn); 1291 1291 1292 - spin_unlock(&irq_mapping_update_lock); 1292 + mutex_unlock(&irq_mapping_update_lock); 1293 1293 1294 1294 /* new event channels are always bound to cpu 0 */ 1295 1295 irq_set_affinity(irq, cpumask_of(0));