tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'akpm' (patches from Andrew)

Merge two mm fixes from Andrew Morton.

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
mm: prevent NR_ISOLATE_* stats from going negative
Revert "mm, page_alloc: only use per-cpu allocator for irq-safe requests"

Linus Torvalds c154165e 160062e1

+21 -24
+1 -1
mm/migrate.c
··· 184 184 unlock_page(page); 185 185 put_page(page); 186 186 } else { 187 - putback_lru_page(page); 188 187 dec_node_page_state(page, NR_ISOLATED_ANON + 189 188 page_is_file_cache(page)); 189 + putback_lru_page(page); 190 190 } 191 191 } 192 192 }
+20 -23
mm/page_alloc.c
··· 1090 1090 { 1091 1091 int migratetype = 0; 1092 1092 int batch_free = 0; 1093 - unsigned long nr_scanned, flags; 1093 + unsigned long nr_scanned; 1094 1094 bool isolated_pageblocks; 1095 1095 1096 - spin_lock_irqsave(&zone->lock, flags); 1096 + spin_lock(&zone->lock); 1097 1097 isolated_pageblocks = has_isolate_pageblock(zone); 1098 1098 nr_scanned = node_page_state(zone->zone_pgdat, NR_PAGES_SCANNED); 1099 1099 if (nr_scanned) ··· 1142 1142 trace_mm_page_pcpu_drain(page, 0, mt); 1143 1143 } while (--count && --batch_free && !list_empty(list)); 1144 1144 } 1145 - spin_unlock_irqrestore(&zone->lock, flags); 1145 + spin_unlock(&zone->lock); 1146 1146 } 1147 1147 1148 1148 static void free_one_page(struct zone *zone, ··· 1150 1150 unsigned int order, 1151 1151 int migratetype) 1152 1152 { 1153 - unsigned long nr_scanned, flags; 1154 - spin_lock_irqsave(&zone->lock, flags); 1155 - __count_vm_events(PGFREE, 1 << order); 1153 + unsigned long nr_scanned; 1154 + spin_lock(&zone->lock); 1156 1155 nr_scanned = node_page_state(zone->zone_pgdat, NR_PAGES_SCANNED); 1157 1156 if (nr_scanned) 1158 1157 __mod_node_page_state(zone->zone_pgdat, NR_PAGES_SCANNED, -nr_scanned); ··· 1161 1162 migratetype = get_pfnblock_migratetype(page, pfn); 1162 1163 } 1163 1164 __free_one_page(page, pfn, zone, order, migratetype); 1164 - spin_unlock_irqrestore(&zone->lock, flags); 1165 + spin_unlock(&zone->lock); 1165 1166 } 1166 1167 1167 1168 static void __meminit __init_single_page(struct page *page, unsigned long pfn, ··· 1239 1240 1240 1241 static void __free_pages_ok(struct page *page, unsigned int order) 1241 1242 { 1243 + unsigned long flags; 1242 1244 int migratetype; 1243 1245 unsigned long pfn = page_to_pfn(page); 1244 1246 ··· 1247 1247 return; 1248 1248 1249 1249 migratetype = get_pfnblock_migratetype(page, pfn); 1250 + local_irq_save(flags); 1251 + __count_vm_events(PGFREE, 1 << order); 1250 1252 free_one_page(page_zone(page), page, pfn, order, migratetype); 1253 + local_irq_restore(flags); 1251 1254 } 1252 1255 1253 1256 static void __init __free_pages_boot_core(struct page *page, unsigned int order) ··· 2222 2219 int migratetype, bool cold) 2223 2220 { 2224 2221 int i, alloced = 0; 2225 - unsigned long flags; 2226 2222 2227 - spin_lock_irqsave(&zone->lock, flags); 2223 + spin_lock(&zone->lock); 2228 2224 for (i = 0; i < count; ++i) { 2229 2225 struct page *page = __rmqueue(zone, order, migratetype); 2230 2226 if (unlikely(page == NULL)) ··· 2259 2257 * pages added to the pcp list. 2260 2258 */ 2261 2259 __mod_zone_page_state(zone, NR_FREE_PAGES, -(i << order)); 2262 - spin_unlock_irqrestore(&zone->lock, flags); 2260 + spin_unlock(&zone->lock); 2263 2261 return alloced; 2264 2262 } 2265 2263 ··· 2487 2485 { 2488 2486 struct zone *zone = page_zone(page); 2489 2487 struct per_cpu_pages *pcp; 2488 + unsigned long flags; 2490 2489 unsigned long pfn = page_to_pfn(page); 2491 2490 int migratetype; 2492 - 2493 - if (in_interrupt()) { 2494 - __free_pages_ok(page, 0); 2495 - return; 2496 - } 2497 2491 2498 2492 if (!free_pcp_prepare(page)) 2499 2493 return; 2500 2494 2501 2495 migratetype = get_pfnblock_migratetype(page, pfn); 2502 2496 set_pcppage_migratetype(page, migratetype); 2503 - preempt_disable(); 2497 + local_irq_save(flags); 2498 + __count_vm_event(PGFREE); 2504 2499 2505 2500 /* 2506 2501 * We only track unmovable, reclaimable and movable on pcp lists. ··· 2514 2515 migratetype = MIGRATE_MOVABLE; 2515 2516 } 2516 2517 2517 - __count_vm_event(PGFREE); 2518 2518 pcp = &this_cpu_ptr(zone->pageset)->pcp; 2519 2519 if (!cold) 2520 2520 list_add(&page->lru, &pcp->lists[migratetype]); ··· 2527 2529 } 2528 2530 2529 2531 out: 2530 - preempt_enable(); 2532 + local_irq_restore(flags); 2531 2533 } 2532 2534 2533 2535 /* ··· 2652 2654 { 2653 2655 struct page *page; 2654 2656 2655 - VM_BUG_ON(in_interrupt()); 2656 - 2657 2657 do { 2658 2658 if (list_empty(list)) { 2659 2659 pcp->count += rmqueue_bulk(zone, 0, ··· 2682 2686 struct list_head *list; 2683 2687 bool cold = ((gfp_flags & __GFP_COLD) != 0); 2684 2688 struct page *page; 2689 + unsigned long flags; 2685 2690 2686 - preempt_disable(); 2691 + local_irq_save(flags); 2687 2692 pcp = &this_cpu_ptr(zone->pageset)->pcp; 2688 2693 list = &pcp->lists[migratetype]; 2689 2694 page = __rmqueue_pcplist(zone, migratetype, cold, pcp, list); ··· 2692 2695 __count_zid_vm_events(PGALLOC, page_zonenum(page), 1 << order); 2693 2696 zone_statistics(preferred_zone, zone); 2694 2697 } 2695 - preempt_enable(); 2698 + local_irq_restore(flags); 2696 2699 return page; 2697 2700 } 2698 2701 ··· 2708 2711 unsigned long flags; 2709 2712 struct page *page; 2710 2713 2711 - if (likely(order == 0) && !in_interrupt()) { 2714 + if (likely(order == 0)) { 2712 2715 page = rmqueue_pcplist(preferred_zone, zone, order, 2713 2716 gfp_flags, migratetype); 2714 2717 goto out;