From: Greg Kroah-Hartman Date: Tue, 15 Feb 2011 14:46:23 +0000 (-0800) Subject: .37 patches X-Git-Tag: v2.6.36.4~32 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=b1cbd1ceeb752d48c4aa71b35d08d88bb9454925;p=thirdparty%2Fkernel%2Fstable-queue.git .37 patches --- diff --git a/queue-2.6.37/mm-page-allocator-adjust-the-per-cpu-counter-threshold-when-memory-is-low.patch b/queue-2.6.37/mm-page-allocator-adjust-the-per-cpu-counter-threshold-when-memory-is-low.patch new file mode 100644 index 00000000000..6566fd659b9 --- /dev/null +++ b/queue-2.6.37/mm-page-allocator-adjust-the-per-cpu-counter-threshold-when-memory-is-low.patch @@ -0,0 +1,393 @@ +From 88f5acf88ae6a9778f6d25d0d5d7ec2d57764a97 Mon Sep 17 00:00:00 2001 +From: Mel Gorman +Date: Thu, 13 Jan 2011 15:45:41 -0800 +Subject: mm: page allocator: adjust the per-cpu counter threshold when memory is low + +From: Mel Gorman + +commit 88f5acf88ae6a9778f6d25d0d5d7ec2d57764a97 upstream. + +Commit aa45484 ("calculate a better estimate of NR_FREE_PAGES when memory +is low") noted that watermarks were based on the vmstat NR_FREE_PAGES. To +avoid synchronization overhead, these counters are maintained on a per-cpu +basis and drained both periodically and when a threshold is above a +threshold. On large CPU systems, the difference between the estimate and +real value of NR_FREE_PAGES can be very high. The system can get into a +case where pages are allocated far below the min watermark potentially +causing livelock issues. The commit solved the problem by taking a better +reading of NR_FREE_PAGES when memory was low. + +Unfortately, as reported by Shaohua Li this accurate reading can consume a +large amount of CPU time on systems with many sockets due to cache line +bouncing. This patch takes a different approach. For large machines +where counter drift might be unsafe and while kswapd is awake, the per-cpu +thresholds for the target pgdat are reduced to limit the level of drift to +what should be a safe level. This incurs a performance penalty in heavy +memory pressure by a factor that depends on the workload and the machine +but the machine should function correctly without accidentally exhausting +all memory on a node. There is an additional cost when kswapd wakes and +sleeps but the event is not expected to be frequent - in Shaohua's test +case, there was one recorded sleep and wake event at least. + +To ensure that kswapd wakes up, a safe version of zone_watermark_ok() is +introduced that takes a more accurate reading of NR_FREE_PAGES when called +from wakeup_kswapd, when deciding whether it is really safe to go back to +sleep in sleeping_prematurely() and when deciding if a zone is really +balanced or not in balance_pgdat(). We are still using an expensive +function but limiting how often it is called. + +When the test case is reproduced, the time spent in the watermark +functions is reduced. The following report is on the percentage of time +spent cumulatively spent in the functions zone_nr_free_pages(), +zone_watermark_ok(), __zone_watermark_ok(), zone_watermark_ok_safe(), +zone_page_state_snapshot(), zone_page_state(). + +vanilla 11.6615% +disable-threshold 0.2584% + +David said: + +: We had to pull aa454840 "mm: page allocator: calculate a better estimate +: of NR_FREE_PAGES when memory is low and kswapd is awake" from 2.6.36 +: internally because tests showed that it would cause the machine to stall +: as the result of heavy kswapd activity. I merged it back with this fix as +: it is pending in the -mm tree and it solves the issue we were seeing, so I +: definitely think this should be pushed to -stable (and I would seriously +: consider it for 2.6.37 inclusion even at this late date). + +Signed-off-by: Mel Gorman +Reported-by: Shaohua Li +Reviewed-by: Christoph Lameter +Tested-by: Nicolas Bareil +Cc: David Rientjes +Cc: Kyle McMartin +Signed-off-by: Andrew Morton +Signed-off-by: Linus Torvalds +Signed-off-by: Greg Kroah-Hartman + +--- + include/linux/mmzone.h | 10 ++----- + include/linux/vmstat.h | 5 +++ + mm/mmzone.c | 21 --------------- + mm/page_alloc.c | 35 +++++++++++++++++++------ + mm/vmscan.c | 23 +++++++++------- + mm/vmstat.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++- + 6 files changed, 115 insertions(+), 47 deletions(-) + +--- a/include/linux/mmzone.h ++++ b/include/linux/mmzone.h +@@ -458,12 +458,6 @@ static inline int zone_is_oom_locked(con + return test_bit(ZONE_OOM_LOCKED, &zone->flags); + } + +-#ifdef CONFIG_SMP +-unsigned long zone_nr_free_pages(struct zone *zone); +-#else +-#define zone_nr_free_pages(zone) zone_page_state(zone, NR_FREE_PAGES) +-#endif /* CONFIG_SMP */ +- + /* + * The "priority" of VM scanning is how much of the queues we will scan in one + * go. A value of 12 for DEF_PRIORITY implies that we will scan 1/4096th of the +@@ -661,7 +655,9 @@ typedef struct pglist_data { + extern struct mutex zonelists_mutex; + void build_all_zonelists(void *data); + void wakeup_kswapd(struct zone *zone, int order); +-int zone_watermark_ok(struct zone *z, int order, unsigned long mark, ++bool zone_watermark_ok(struct zone *z, int order, unsigned long mark, ++ int classzone_idx, int alloc_flags); ++bool zone_watermark_ok_safe(struct zone *z, int order, unsigned long mark, + int classzone_idx, int alloc_flags); + enum memmap_context { + MEMMAP_EARLY, +--- a/include/linux/vmstat.h ++++ b/include/linux/vmstat.h +@@ -254,6 +254,8 @@ extern void dec_zone_state(struct zone * + extern void __dec_zone_state(struct zone *, enum zone_stat_item); + + void refresh_cpu_vm_stats(int); ++void reduce_pgdat_percpu_threshold(pg_data_t *pgdat); ++void restore_pgdat_percpu_threshold(pg_data_t *pgdat); + #else /* CONFIG_SMP */ + + /* +@@ -298,6 +300,9 @@ static inline void __dec_zone_page_state + #define dec_zone_page_state __dec_zone_page_state + #define mod_zone_page_state __mod_zone_page_state + ++static inline void reduce_pgdat_percpu_threshold(pg_data_t *pgdat) { } ++static inline void restore_pgdat_percpu_threshold(pg_data_t *pgdat) { } ++ + static inline void refresh_cpu_vm_stats(int cpu) { } + #endif + +--- a/mm/mmzone.c ++++ b/mm/mmzone.c +@@ -87,24 +87,3 @@ int memmap_valid_within(unsigned long pf + return 1; + } + #endif /* CONFIG_ARCH_HAS_HOLES_MEMORYMODEL */ +- +-#ifdef CONFIG_SMP +-/* Called when a more accurate view of NR_FREE_PAGES is needed */ +-unsigned long zone_nr_free_pages(struct zone *zone) +-{ +- unsigned long nr_free_pages = zone_page_state(zone, NR_FREE_PAGES); +- +- /* +- * While kswapd is awake, it is considered the zone is under some +- * memory pressure. Under pressure, there is a risk that +- * per-cpu-counter-drift will allow the min watermark to be breached +- * potentially causing a live-lock. While kswapd is awake and +- * free pages are low, get a better estimate for free pages +- */ +- if (nr_free_pages < zone->percpu_drift_mark && +- !waitqueue_active(&zone->zone_pgdat->kswapd_wait)) +- return zone_page_state_snapshot(zone, NR_FREE_PAGES); +- +- return nr_free_pages; +-} +-#endif /* CONFIG_SMP */ +--- a/mm/page_alloc.c ++++ b/mm/page_alloc.c +@@ -1460,24 +1460,24 @@ static inline int should_fail_alloc_page + #endif /* CONFIG_FAIL_PAGE_ALLOC */ + + /* +- * Return 1 if free pages are above 'mark'. This takes into account the order ++ * Return true if free pages are above 'mark'. This takes into account the order + * of the allocation. + */ +-int zone_watermark_ok(struct zone *z, int order, unsigned long mark, +- int classzone_idx, int alloc_flags) ++static bool __zone_watermark_ok(struct zone *z, int order, unsigned long mark, ++ int classzone_idx, int alloc_flags, long free_pages) + { + /* free_pages my go negative - that's OK */ + long min = mark; +- long free_pages = zone_nr_free_pages(z) - (1 << order) + 1; + int o; + ++ free_pages -= (1 << order) + 1; + if (alloc_flags & ALLOC_HIGH) + min -= min / 2; + if (alloc_flags & ALLOC_HARDER) + min -= min / 4; + + if (free_pages <= min + z->lowmem_reserve[classzone_idx]) +- return 0; ++ return false; + for (o = 0; o < order; o++) { + /* At the next order, this order's pages become unavailable */ + free_pages -= z->free_area[o].nr_free << o; +@@ -1486,9 +1486,28 @@ int zone_watermark_ok(struct zone *z, in + min >>= 1; + + if (free_pages <= min) +- return 0; ++ return false; + } +- return 1; ++ return true; ++} ++ ++bool zone_watermark_ok(struct zone *z, int order, unsigned long mark, ++ int classzone_idx, int alloc_flags) ++{ ++ return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags, ++ zone_page_state(z, NR_FREE_PAGES)); ++} ++ ++bool zone_watermark_ok_safe(struct zone *z, int order, unsigned long mark, ++ int classzone_idx, int alloc_flags) ++{ ++ long free_pages = zone_page_state(z, NR_FREE_PAGES); ++ ++ if (z->percpu_drift_mark && free_pages < z->percpu_drift_mark) ++ free_pages = zone_page_state_snapshot(z, NR_FREE_PAGES); ++ ++ return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags, ++ free_pages); + } + + #ifdef CONFIG_NUMA +@@ -2442,7 +2461,7 @@ void show_free_areas(void) + " all_unreclaimable? %s" + "\n", + zone->name, +- K(zone_nr_free_pages(zone)), ++ K(zone_page_state(zone, NR_FREE_PAGES)), + K(min_wmark_pages(zone)), + K(low_wmark_pages(zone)), + K(high_wmark_pages(zone)), +--- a/mm/vmscan.c ++++ b/mm/vmscan.c +@@ -2143,7 +2143,7 @@ static int sleeping_prematurely(pg_data_ + if (zone->all_unreclaimable) + continue; + +- if (!zone_watermark_ok(zone, order, high_wmark_pages(zone), ++ if (!zone_watermark_ok_safe(zone, order, high_wmark_pages(zone), + 0, 0)) + return 1; + } +@@ -2230,7 +2230,7 @@ loop_again: + shrink_active_list(SWAP_CLUSTER_MAX, zone, + &sc, priority, 0); + +- if (!zone_watermark_ok(zone, order, ++ if (!zone_watermark_ok_safe(zone, order, + high_wmark_pages(zone), 0, 0)) { + end_zone = i; + break; +@@ -2276,7 +2276,7 @@ loop_again: + * We put equal pressure on every zone, unless one + * zone has way too many pages free already. + */ +- if (!zone_watermark_ok(zone, order, ++ if (!zone_watermark_ok_safe(zone, order, + 8*high_wmark_pages(zone), end_zone, 0)) + shrink_zone(priority, zone, &sc); + reclaim_state->reclaimed_slab = 0; +@@ -2297,7 +2297,7 @@ loop_again: + total_scanned > sc.nr_reclaimed + sc.nr_reclaimed / 2) + sc.may_writepage = 1; + +- if (!zone_watermark_ok(zone, order, ++ if (!zone_watermark_ok_safe(zone, order, + high_wmark_pages(zone), end_zone, 0)) { + all_zones_ok = 0; + /* +@@ -2305,7 +2305,7 @@ loop_again: + * means that we have a GFP_ATOMIC allocation + * failure risk. Hurry up! + */ +- if (!zone_watermark_ok(zone, order, ++ if (!zone_watermark_ok_safe(zone, order, + min_wmark_pages(zone), end_zone, 0)) + has_under_min_watermark_zone = 1; + } else { +@@ -2448,7 +2448,9 @@ static int kswapd(void *p) + */ + if (!sleeping_prematurely(pgdat, order, remaining)) { + trace_mm_vmscan_kswapd_sleep(pgdat->node_id); ++ restore_pgdat_percpu_threshold(pgdat); + schedule(); ++ reduce_pgdat_percpu_threshold(pgdat); + } else { + if (remaining) + count_vm_event(KSWAPD_LOW_WMARK_HIT_QUICKLY); +@@ -2487,16 +2489,17 @@ void wakeup_kswapd(struct zone *zone, in + if (!populated_zone(zone)) + return; + +- pgdat = zone->zone_pgdat; +- if (zone_watermark_ok(zone, order, low_wmark_pages(zone), 0, 0)) ++ if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL)) + return; ++ pgdat = zone->zone_pgdat; + if (pgdat->kswapd_max_order < order) + pgdat->kswapd_max_order = order; +- trace_mm_vmscan_wakeup_kswapd(pgdat->node_id, zone_idx(zone), order); +- if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL)) +- return; + if (!waitqueue_active(&pgdat->kswapd_wait)) + return; ++ if (zone_watermark_ok_safe(zone, order, low_wmark_pages(zone), 0, 0)) ++ return; ++ ++ trace_mm_vmscan_wakeup_kswapd(pgdat->node_id, zone_idx(zone), order); + wake_up_interruptible(&pgdat->kswapd_wait); + } + +--- a/mm/vmstat.c ++++ b/mm/vmstat.c +@@ -83,6 +83,30 @@ EXPORT_SYMBOL(vm_stat); + + #ifdef CONFIG_SMP + ++static int calculate_pressure_threshold(struct zone *zone) ++{ ++ int threshold; ++ int watermark_distance; ++ ++ /* ++ * As vmstats are not up to date, there is drift between the estimated ++ * and real values. For high thresholds and a high number of CPUs, it ++ * is possible for the min watermark to be breached while the estimated ++ * value looks fine. The pressure threshold is a reduced value such ++ * that even the maximum amount of drift will not accidentally breach ++ * the min watermark ++ */ ++ watermark_distance = low_wmark_pages(zone) - min_wmark_pages(zone); ++ threshold = max(1, (int)(watermark_distance / num_online_cpus())); ++ ++ /* ++ * Maximum threshold is 125 ++ */ ++ threshold = min(125, threshold); ++ ++ return threshold; ++} ++ + static int calculate_threshold(struct zone *zone) + { + int threshold; +@@ -161,6 +185,48 @@ static void refresh_zone_stat_thresholds + } + } + ++void reduce_pgdat_percpu_threshold(pg_data_t *pgdat) ++{ ++ struct zone *zone; ++ int cpu; ++ int threshold; ++ int i; ++ ++ get_online_cpus(); ++ for (i = 0; i < pgdat->nr_zones; i++) { ++ zone = &pgdat->node_zones[i]; ++ if (!zone->percpu_drift_mark) ++ continue; ++ ++ threshold = calculate_pressure_threshold(zone); ++ for_each_online_cpu(cpu) ++ per_cpu_ptr(zone->pageset, cpu)->stat_threshold ++ = threshold; ++ } ++ put_online_cpus(); ++} ++ ++void restore_pgdat_percpu_threshold(pg_data_t *pgdat) ++{ ++ struct zone *zone; ++ int cpu; ++ int threshold; ++ int i; ++ ++ get_online_cpus(); ++ for (i = 0; i < pgdat->nr_zones; i++) { ++ zone = &pgdat->node_zones[i]; ++ if (!zone->percpu_drift_mark) ++ continue; ++ ++ threshold = calculate_threshold(zone); ++ for_each_online_cpu(cpu) ++ per_cpu_ptr(zone->pageset, cpu)->stat_threshold ++ = threshold; ++ } ++ put_online_cpus(); ++} ++ + /* + * For use when we know that interrupts are disabled. + */ +@@ -834,7 +900,7 @@ static void zoneinfo_show_print(struct s + "\n scanned %lu" + "\n spanned %lu" + "\n present %lu", +- zone_nr_free_pages(zone), ++ zone_page_state(zone, NR_FREE_PAGES), + min_wmark_pages(zone), + low_wmark_pages(zone), + high_wmark_pages(zone), diff --git a/queue-2.6.37/net-ax25-fix-information-leak-to-userland-harder.patch b/queue-2.6.37/net-ax25-fix-information-leak-to-userland-harder.patch new file mode 100644 index 00000000000..d1ace21c157 --- /dev/null +++ b/queue-2.6.37/net-ax25-fix-information-leak-to-userland-harder.patch @@ -0,0 +1,33 @@ +From 5b919f833d9d60588d026ad82d17f17e8872c7a9 Mon Sep 17 00:00:00 2001 +From: Kees Cook +Date: Wed, 12 Jan 2011 00:34:49 -0800 +Subject: net: ax25: fix information leak to userland harder + +From: Kees Cook + +commit 5b919f833d9d60588d026ad82d17f17e8872c7a9 upstream. + +Commit fe10ae53384e48c51996941b7720ee16995cbcb7 adds a memset() to clear +the structure being sent back to userspace, but accidentally used the +wrong size. + +Reported-by: Brad Spengler +Signed-off-by: Kees Cook +Signed-off-by: David S. Miller +Signed-off-by: Greg Kroah-Hartman + +--- + net/ax25/af_ax25.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/net/ax25/af_ax25.c ++++ b/net/ax25/af_ax25.c +@@ -1392,7 +1392,7 @@ static int ax25_getname(struct socket *s + ax25_cb *ax25; + int err = 0; + +- memset(fsa, 0, sizeof(fsa)); ++ memset(fsa, 0, sizeof(*fsa)); + lock_sock(sk); + ax25 = ax25_sk(sk); + diff --git a/queue-2.6.37/revert-exofs-set-i_mapping-backing_dev_info-anyway.patch b/queue-2.6.37/revert-exofs-set-i_mapping-backing_dev_info-anyway.patch new file mode 100644 index 00000000000..82e154495c0 --- /dev/null +++ b/queue-2.6.37/revert-exofs-set-i_mapping-backing_dev_info-anyway.patch @@ -0,0 +1,45 @@ +From 0b0abeaf3d30cec03ac6497fe978b8f7edecc5ae Mon Sep 17 00:00:00 2001 +From: Boaz Harrosh +Date: Wed, 2 Feb 2011 21:02:12 +0200 +Subject: Revert "exofs: Set i_mapping->backing_dev_info anyway" + +From: Boaz Harrosh + +commit 0b0abeaf3d30cec03ac6497fe978b8f7edecc5ae upstream. + +This reverts commit 115e19c53501edc11f730191f7f047736815ae3d. + +Apparently setting inode->bdi to one's own sb->s_bdi stops VFS from +sending *read-aheads*. This problem was bisected to this commit. A +revert fixes it. I'll investigate farther why is this happening for the +next Kernel, but for now a revert. + +I'm sending to stable@kernel.org as well, since it exists also in +2.6.37. 2.6.36 is good and does not have this patch. + +Signed-off-by: Boaz Harrosh +Signed-off-by: Linus Torvalds +Signed-off-by: Greg Kroah-Hartman + +--- + fs/exofs/inode.c | 2 -- + 1 file changed, 2 deletions(-) + +--- a/fs/exofs/inode.c ++++ b/fs/exofs/inode.c +@@ -1030,7 +1030,6 @@ struct inode *exofs_iget(struct super_bl + memcpy(oi->i_data, fcb.i_data, sizeof(fcb.i_data)); + } + +- inode->i_mapping->backing_dev_info = sb->s_bdi; + if (S_ISREG(inode->i_mode)) { + inode->i_op = &exofs_file_inode_operations; + inode->i_fop = &exofs_file_operations; +@@ -1131,7 +1130,6 @@ struct inode *exofs_new_inode(struct ino + + sbi = sb->s_fs_info; + +- inode->i_mapping->backing_dev_info = sb->s_bdi; + sb->s_dirt = 1; + inode_init_owner(inode, dir, mode); + inode->i_ino = sbi->s_nextid++; diff --git a/queue-2.6.37/series b/queue-2.6.37/series index 5bff69601f5..175486030bb 100644 --- a/queue-2.6.37/series +++ b/queue-2.6.37/series @@ -174,3 +174,9 @@ arm-s5pv310-set-bit-22-in-the-pl310-cache-controller-auxctlr-register.patch arm-initrd-disable-initrd-if-passed-address-overlaps-reserved-region.patch memcg-fix-account-leak-at-failure-of-memsw-acconting.patch mmc-bfin_sdh-fix-alloc-size-for-private-data.patch +revert-exofs-set-i_mapping-backing_dev_info-anyway.patch +slub-avoid-use-of-slub_lock-in-show_slab_objects.patch +x86-olpc-add-missing-kconfig-dependencies.patch +net-ax25-fix-information-leak-to-userland-harder.patch +xen-platform-use-pci-interfaces-to-request-io-and-mem-resources.patch +mm-page-allocator-adjust-the-per-cpu-counter-threshold-when-memory-is-low.patch diff --git a/queue-2.6.37/slub-avoid-use-of-slub_lock-in-show_slab_objects.patch b/queue-2.6.37/slub-avoid-use-of-slub_lock-in-show_slab_objects.patch new file mode 100644 index 00000000000..1e6cb5854f2 --- /dev/null +++ b/queue-2.6.37/slub-avoid-use-of-slub_lock-in-show_slab_objects.patch @@ -0,0 +1,52 @@ +From 04d94879c8a4973b5499dc26b9d38acee8928791 Mon Sep 17 00:00:00 2001 +From: Christoph Lameter +Date: Mon, 10 Jan 2011 10:15:15 -0600 +Subject: slub: Avoid use of slub_lock in show_slab_objects() + +From: Christoph Lameter + +commit 04d94879c8a4973b5499dc26b9d38acee8928791 upstream. + +The purpose of the locking is to prevent removal and additions +of nodes when statistics are gathered for a slab cache. So we +need to avoid racing with memory hotplug functionality. + +It is enough to take the memory hotplug locks there instead +of the slub_lock. + +online_pages() currently does not acquire the memory_hotplug +lock. Another patch will be submitted by the memory hotplug +authors to take the memory hotplug lock and describe the +uses of the memory hotplug lock to protect against +adding and removal of nodes from non hotplug data structures. + +Reported-and-tested-by: Bart Van Assche +Acked-by: David Rientjes +Signed-off-by: Christoph Lameter +Signed-off-by: Pekka Enberg +Signed-off-by: Greg Kroah-Hartman + +--- + mm/slub.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/mm/slub.c ++++ b/mm/slub.c +@@ -3821,7 +3821,7 @@ static ssize_t show_slab_objects(struct + } + } + +- down_read(&slub_lock); ++ lock_memory_hotplug(); + #ifdef CONFIG_SLUB_DEBUG + if (flags & SO_ALL) { + for_each_node_state(node, N_NORMAL_MEMORY) { +@@ -3862,7 +3862,7 @@ static ssize_t show_slab_objects(struct + x += sprintf(buf + x, " N%d=%lu", + node, nodes[node]); + #endif +- up_read(&slub_lock); ++ unlock_memory_hotplug(); + kfree(nodes); + return x + sprintf(buf + x, "\n"); + } diff --git a/queue-2.6.37/x86-olpc-add-missing-kconfig-dependencies.patch b/queue-2.6.37/x86-olpc-add-missing-kconfig-dependencies.patch new file mode 100644 index 00000000000..c01e495eb82 --- /dev/null +++ b/queue-2.6.37/x86-olpc-add-missing-kconfig-dependencies.patch @@ -0,0 +1,33 @@ +From 76d1f7bfcd5872056902c5a88b5fcd5d4d00a7a9 Mon Sep 17 00:00:00 2001 +From: H. Peter Anvin +Date: Fri, 14 Jan 2011 11:57:06 -0800 +Subject: x86, olpc: Add missing Kconfig dependencies + +From: H. Peter Anvin + +commit 76d1f7bfcd5872056902c5a88b5fcd5d4d00a7a9 upstream. + +OLPC uses select for OLPC_OPENFIRMWARE, which means OLPC has to +enforce the dependencies for OLPC_OPENFIRMWARE. Make sure it does so. + +Signed-off-by: H. Peter Anvin +Cc: Daniel Drake +Cc: Andres Salomon +Cc: Grant Likely +LKML-Reference: <20100923162846.D8D409D401B@zog.reactivated.net> +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/Kconfig | 1 + + 1 file changed, 1 insertion(+) + +--- a/arch/x86/Kconfig ++++ b/arch/x86/Kconfig +@@ -2035,6 +2035,7 @@ config OLPC + bool "One Laptop Per Child support" + select GPIOLIB + select OLPC_OPENFIRMWARE ++ depends on !X86_64 && !X86_PAE + ---help--- + Add support for detecting the unique features of the OLPC + XO hardware. diff --git a/queue-2.6.37/xen-platform-use-pci-interfaces-to-request-io-and-mem-resources.patch b/queue-2.6.37/xen-platform-use-pci-interfaces-to-request-io-and-mem-resources.patch new file mode 100644 index 00000000000..783ccb7e6bb --- /dev/null +++ b/queue-2.6.37/xen-platform-use-pci-interfaces-to-request-io-and-mem-resources.patch @@ -0,0 +1,77 @@ +From 00f28e4037c8d5782fa7a1b2666b0dca21522d69 Mon Sep 17 00:00:00 2001 +From: Ian Campbell +Date: Tue, 11 Jan 2011 11:50:28 +0000 +Subject: xen-platform: use PCI interfaces to request IO and MEM resources. + +From: Ian Campbell + +commit 00f28e4037c8d5782fa7a1b2666b0dca21522d69 upstream. + +This is the correct interface to use and something has broken the use +of the previous incorrect interface (which fails because the request +conflicts with the resources assigned for the PCI device itself +instead of nesting like the PCI interfaces do). + +Signed-off-by: Ian Campbell +Signed-off-by: Konrad Rzeszutek Wilk +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/xen/platform-pci.c | 21 +++++++-------------- + 1 file changed, 7 insertions(+), 14 deletions(-) + +--- a/drivers/xen/platform-pci.c ++++ b/drivers/xen/platform-pci.c +@@ -105,7 +105,7 @@ static int __devinit platform_pci_init(s + const struct pci_device_id *ent) + { + int i, ret; +- long ioaddr, iolen; ++ long ioaddr; + long mmio_addr, mmio_len; + unsigned int max_nr_gframes; + +@@ -114,7 +114,6 @@ static int __devinit platform_pci_init(s + return i; + + ioaddr = pci_resource_start(pdev, 0); +- iolen = pci_resource_len(pdev, 0); + + mmio_addr = pci_resource_start(pdev, 1); + mmio_len = pci_resource_len(pdev, 1); +@@ -125,19 +124,13 @@ static int __devinit platform_pci_init(s + goto pci_out; + } + +- if (request_mem_region(mmio_addr, mmio_len, DRV_NAME) == NULL) { +- dev_err(&pdev->dev, "MEM I/O resource 0x%lx @ 0x%lx busy\n", +- mmio_addr, mmio_len); +- ret = -EBUSY; ++ ret = pci_request_region(pdev, 1, DRV_NAME); ++ if (ret < 0) + goto pci_out; +- } + +- if (request_region(ioaddr, iolen, DRV_NAME) == NULL) { +- dev_err(&pdev->dev, "I/O resource 0x%lx @ 0x%lx busy\n", +- iolen, ioaddr); +- ret = -EBUSY; ++ ret = pci_request_region(pdev, 0, DRV_NAME); ++ if (ret < 0) + goto mem_out; +- } + + platform_mmio = mmio_addr; + platform_mmiolen = mmio_len; +@@ -169,9 +162,9 @@ static int __devinit platform_pci_init(s + return 0; + + out: +- release_region(ioaddr, iolen); ++ pci_release_region(pdev, 0); + mem_out: +- release_mem_region(mmio_addr, mmio_len); ++ pci_release_region(pdev, 1); + pci_out: + pci_disable_device(pdev); + return ret;