| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20170316080240.GB30501@dhcp22.suse.cz>
Date: Thu, 16 Mar 2017 09:02:40 +0100
From: Michal Hocko <mhocko@...nel.org>
To: Joe Perches <joe@...ches.com>
Cc: Andrew Morton <akpm@...ux-foundation.org>,
linux-kernel@...r.kernel.org, linux-mm@...ck.org
Subject: Re: [PATCH 02/15] mm: page_alloc: align arguments to parenthesis
On Wed 15-03-17 18:59:59, Joe Perches wrote:
> whitespace changes only - git diff -w shows no difference
what is the point of this whitespace noise? Does it help readability?
To be honest I do not think so. Such a patch would make sense only if it
was a part of a larger series where other patches would actually do
something useful.
> Signed-off-by: Joe Perches <joe@...ches.com>
> ---
> mm/page_alloc.c | 552 ++++++++++++++++++++++++++++----------------------------
> 1 file changed, 276 insertions(+), 276 deletions(-)
>
> diff --git a/mm/page_alloc.c b/mm/page_alloc.c
> index 504749032400..79fc996892c6 100644
> --- a/mm/page_alloc.c
> +++ b/mm/page_alloc.c
> @@ -204,33 +204,33 @@ static void __free_pages_ok(struct page *page, unsigned int order);
> */
> int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES - 1] = {
> #ifdef CONFIG_ZONE_DMA
> - 256,
> + 256,
> #endif
> #ifdef CONFIG_ZONE_DMA32
> - 256,
> + 256,
> #endif
> #ifdef CONFIG_HIGHMEM
> - 32,
> + 32,
> #endif
> - 32,
> + 32,
> };
>
> EXPORT_SYMBOL(totalram_pages);
>
> static char * const zone_names[MAX_NR_ZONES] = {
> #ifdef CONFIG_ZONE_DMA
> - "DMA",
> + "DMA",
> #endif
> #ifdef CONFIG_ZONE_DMA32
> - "DMA32",
> + "DMA32",
> #endif
> - "Normal",
> + "Normal",
> #ifdef CONFIG_HIGHMEM
> - "HighMem",
> + "HighMem",
> #endif
> - "Movable",
> + "Movable",
> #ifdef CONFIG_ZONE_DEVICE
> - "Device",
> + "Device",
> #endif
> };
>
> @@ -310,8 +310,8 @@ static inline bool __meminit early_page_uninitialised(unsigned long pfn)
> * later in the boot cycle when it can be parallelised.
> */
> static inline bool update_defer_init(pg_data_t *pgdat,
> - unsigned long pfn, unsigned long zone_end,
> - unsigned long *nr_initialised)
> + unsigned long pfn, unsigned long zone_end,
> + unsigned long *nr_initialised)
> {
> unsigned long max_initialise;
>
> @@ -323,7 +323,7 @@ static inline bool update_defer_init(pg_data_t *pgdat,
> * two large system hashes that can take up 1GB for 0.25TB/node.
> */
> max_initialise = max(2UL << (30 - PAGE_SHIFT),
> - (pgdat->node_spanned_pages >> 8));
> + (pgdat->node_spanned_pages >> 8));
>
> (*nr_initialised)++;
> if ((*nr_initialised > max_initialise) &&
> @@ -345,8 +345,8 @@ static inline bool early_page_uninitialised(unsigned long pfn)
> }
>
> static inline bool update_defer_init(pg_data_t *pgdat,
> - unsigned long pfn, unsigned long zone_end,
> - unsigned long *nr_initialised)
> + unsigned long pfn, unsigned long zone_end,
> + unsigned long *nr_initialised)
> {
> return true;
> }
> @@ -354,7 +354,7 @@ static inline bool update_defer_init(pg_data_t *pgdat,
>
> /* Return a pointer to the bitmap storing bits affecting a block of pages */
> static inline unsigned long *get_pageblock_bitmap(struct page *page,
> - unsigned long pfn)
> + unsigned long pfn)
> {
> #ifdef CONFIG_SPARSEMEM
> return __pfn_to_section(pfn)->pageblock_flags;
> @@ -384,9 +384,9 @@ static inline int pfn_to_bitidx(struct page *page, unsigned long pfn)
> * Return: pageblock_bits flags
> */
> static __always_inline unsigned long __get_pfnblock_flags_mask(struct page *page,
> - unsigned long pfn,
> - unsigned long end_bitidx,
> - unsigned long mask)
> + unsigned long pfn,
> + unsigned long end_bitidx,
> + unsigned long mask)
> {
> unsigned long *bitmap;
> unsigned long bitidx, word_bitidx;
> @@ -403,8 +403,8 @@ static __always_inline unsigned long __get_pfnblock_flags_mask(struct page *page
> }
>
> unsigned long get_pfnblock_flags_mask(struct page *page, unsigned long pfn,
> - unsigned long end_bitidx,
> - unsigned long mask)
> + unsigned long end_bitidx,
> + unsigned long mask)
> {
> return __get_pfnblock_flags_mask(page, pfn, end_bitidx, mask);
> }
> @@ -423,9 +423,9 @@ static __always_inline int get_pfnblock_migratetype(struct page *page, unsigned
> * @mask: mask of bits that the caller is interested in
> */
> void set_pfnblock_flags_mask(struct page *page, unsigned long flags,
> - unsigned long pfn,
> - unsigned long end_bitidx,
> - unsigned long mask)
> + unsigned long pfn,
> + unsigned long end_bitidx,
> + unsigned long mask)
> {
> unsigned long *bitmap;
> unsigned long bitidx, word_bitidx;
> @@ -460,7 +460,7 @@ void set_pageblock_migratetype(struct page *page, int migratetype)
> migratetype = MIGRATE_UNMOVABLE;
>
> set_pageblock_flags_group(page, (unsigned long)migratetype,
> - PB_migrate, PB_migrate_end);
> + PB_migrate, PB_migrate_end);
> }
>
> #ifdef CONFIG_DEBUG_VM
> @@ -481,8 +481,8 @@ static int page_outside_zone_boundaries(struct zone *zone, struct page *page)
>
> if (ret)
> pr_err("page 0x%lx outside node %d zone %s [ 0x%lx - 0x%lx ]\n",
> - pfn, zone_to_nid(zone), zone->name,
> - start_pfn, start_pfn + sp);
> + pfn, zone_to_nid(zone), zone->name,
> + start_pfn, start_pfn + sp);
>
> return ret;
> }
> @@ -516,7 +516,7 @@ static inline int bad_range(struct zone *zone, struct page *page)
> #endif
>
> static void bad_page(struct page *page, const char *reason,
> - unsigned long bad_flags)
> + unsigned long bad_flags)
> {
> static unsigned long resume;
> static unsigned long nr_shown;
> @@ -533,7 +533,7 @@ static void bad_page(struct page *page, const char *reason,
> }
> if (nr_unshown) {
> pr_alert(
> - "BUG: Bad page state: %lu messages suppressed\n",
> + "BUG: Bad page state: %lu messages suppressed\n",
> nr_unshown);
> nr_unshown = 0;
> }
> @@ -543,12 +543,12 @@ static void bad_page(struct page *page, const char *reason,
> resume = jiffies + 60 * HZ;
>
> pr_alert("BUG: Bad page state in process %s pfn:%05lx\n",
> - current->comm, page_to_pfn(page));
> + current->comm, page_to_pfn(page));
> __dump_page(page, reason);
> bad_flags &= page->flags;
> if (bad_flags)
> pr_alert("bad because of flags: %#lx(%pGp)\n",
> - bad_flags, &bad_flags);
> + bad_flags, &bad_flags);
> dump_page_owner(page);
>
> print_modules();
> @@ -599,7 +599,7 @@ void prep_compound_page(struct page *page, unsigned int order)
> #ifdef CONFIG_DEBUG_PAGEALLOC
> unsigned int _debug_guardpage_minorder;
> bool _debug_pagealloc_enabled __read_mostly
> - = IS_ENABLED(CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT);
> += IS_ENABLED(CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT);
> EXPORT_SYMBOL(_debug_pagealloc_enabled);
> bool _debug_guardpage_enabled __read_mostly;
>
> @@ -654,7 +654,7 @@ static int __init debug_guardpage_minorder_setup(char *buf)
> early_param("debug_guardpage_minorder", debug_guardpage_minorder_setup);
>
> static inline bool set_page_guard(struct zone *zone, struct page *page,
> - unsigned int order, int migratetype)
> + unsigned int order, int migratetype)
> {
> struct page_ext *page_ext;
>
> @@ -679,7 +679,7 @@ static inline bool set_page_guard(struct zone *zone, struct page *page,
> }
>
> static inline void clear_page_guard(struct zone *zone, struct page *page,
> - unsigned int order, int migratetype)
> + unsigned int order, int migratetype)
> {
> struct page_ext *page_ext;
>
> @@ -699,9 +699,9 @@ static inline void clear_page_guard(struct zone *zone, struct page *page,
> #else
> struct page_ext_operations debug_guardpage_ops;
> static inline bool set_page_guard(struct zone *zone, struct page *page,
> - unsigned int order, int migratetype) { return false; }
> + unsigned int order, int migratetype) { return false; }
> static inline void clear_page_guard(struct zone *zone, struct page *page,
> - unsigned int order, int migratetype) {}
> + unsigned int order, int migratetype) {}
> #endif
>
> static inline void set_page_order(struct page *page, unsigned int order)
> @@ -732,7 +732,7 @@ static inline void rmv_page_order(struct page *page)
> * For recording page's order, we use page_private(page).
> */
> static inline int page_is_buddy(struct page *page, struct page *buddy,
> - unsigned int order)
> + unsigned int order)
> {
> if (page_is_guard(buddy) && page_order(buddy) == order) {
> if (page_zone_id(page) != page_zone_id(buddy))
> @@ -785,9 +785,9 @@ static inline int page_is_buddy(struct page *page, struct page *buddy,
> */
>
> static inline void __free_one_page(struct page *page,
> - unsigned long pfn,
> - struct zone *zone, unsigned int order,
> - int migratetype)
> + unsigned long pfn,
> + struct zone *zone, unsigned int order,
> + int migratetype)
> {
> unsigned long combined_pfn;
> unsigned long uninitialized_var(buddy_pfn);
> @@ -848,8 +848,8 @@ static inline void __free_one_page(struct page *page,
> buddy_mt = get_pageblock_migratetype(buddy);
>
> if (migratetype != buddy_mt
> - && (is_migrate_isolate(migratetype) ||
> - is_migrate_isolate(buddy_mt)))
> + && (is_migrate_isolate(migratetype) ||
> + is_migrate_isolate(buddy_mt)))
> goto done_merging;
> }
> max_order++;
> @@ -876,7 +876,7 @@ static inline void __free_one_page(struct page *page,
> if (pfn_valid_within(buddy_pfn) &&
> page_is_buddy(higher_page, higher_buddy, order + 1)) {
> list_add_tail(&page->lru,
> - &zone->free_area[order].free_list[migratetype]);
> + &zone->free_area[order].free_list[migratetype]);
> goto out;
> }
> }
> @@ -892,17 +892,17 @@ static inline void __free_one_page(struct page *page,
> * check if necessary.
> */
> static inline bool page_expected_state(struct page *page,
> - unsigned long check_flags)
> + unsigned long check_flags)
> {
> if (unlikely(atomic_read(&page->_mapcount) != -1))
> return false;
>
> if (unlikely((unsigned long)page->mapping |
> - page_ref_count(page) |
> + page_ref_count(page) |
> #ifdef CONFIG_MEMCG
> - (unsigned long)page->mem_cgroup |
> + (unsigned long)page->mem_cgroup |
> #endif
> - (page->flags & check_flags)))
> + (page->flags & check_flags)))
> return false;
>
> return true;
> @@ -994,7 +994,7 @@ static int free_tail_pages_check(struct page *head_page, struct page *page)
> }
>
> static __always_inline bool free_pages_prepare(struct page *page,
> - unsigned int order, bool check_free)
> + unsigned int order, bool check_free)
> {
> int bad = 0;
>
> @@ -1042,7 +1042,7 @@ static __always_inline bool free_pages_prepare(struct page *page,
> debug_check_no_locks_freed(page_address(page),
> PAGE_SIZE << order);
> debug_check_no_obj_freed(page_address(page),
> - PAGE_SIZE << order);
> + PAGE_SIZE << order);
> }
> arch_free_page(page, order);
> kernel_poison_pages(page, 1 << order, 0);
> @@ -1086,7 +1086,7 @@ static bool bulkfree_pcp_prepare(struct page *page)
> * pinned" detection logic.
> */
> static void free_pcppages_bulk(struct zone *zone, int count,
> - struct per_cpu_pages *pcp)
> + struct per_cpu_pages *pcp)
> {
> int migratetype = 0;
> int batch_free = 0;
> @@ -1142,16 +1142,16 @@ static void free_pcppages_bulk(struct zone *zone, int count,
> }
>
> static void free_one_page(struct zone *zone,
> - struct page *page, unsigned long pfn,
> - unsigned int order,
> - int migratetype)
> + struct page *page, unsigned long pfn,
> + unsigned int order,
> + int migratetype)
> {
> unsigned long flags;
>
> spin_lock_irqsave(&zone->lock, flags);
> __count_vm_events(PGFREE, 1 << order);
> if (unlikely(has_isolate_pageblock(zone) ||
> - is_migrate_isolate(migratetype))) {
> + is_migrate_isolate(migratetype))) {
> migratetype = get_pfnblock_migratetype(page, pfn);
> }
> __free_one_page(page, pfn, zone, order, migratetype);
> @@ -1159,7 +1159,7 @@ static void free_one_page(struct zone *zone,
> }
>
> static void __meminit __init_single_page(struct page *page, unsigned long pfn,
> - unsigned long zone, int nid)
> + unsigned long zone, int nid)
> {
> set_page_links(page, zone, nid, pfn);
> init_page_count(page);
> @@ -1263,7 +1263,7 @@ static void __init __free_pages_boot_core(struct page *page, unsigned int order)
> __free_pages(page, order);
> }
>
> -#if defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) || \
> +#if defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) || \
> defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
>
> static struct mminit_pfnnid_cache early_pfnnid_cache __meminitdata;
> @@ -1285,7 +1285,7 @@ int __meminit early_pfn_to_nid(unsigned long pfn)
>
> #ifdef CONFIG_NODES_SPAN_OTHER_NODES
> static inline bool __meminit meminit_pfn_in_nid(unsigned long pfn, int node,
> - struct mminit_pfnnid_cache *state)
> + struct mminit_pfnnid_cache *state)
> {
> int nid;
>
> @@ -1308,7 +1308,7 @@ static inline bool __meminit early_pfn_in_nid(unsigned long pfn, int node)
> return true;
> }
> static inline bool __meminit meminit_pfn_in_nid(unsigned long pfn, int node,
> - struct mminit_pfnnid_cache *state)
> + struct mminit_pfnnid_cache *state)
> {
> return true;
> }
> @@ -1316,7 +1316,7 @@ static inline bool __meminit meminit_pfn_in_nid(unsigned long pfn, int node,
>
>
> void __init __free_pages_bootmem(struct page *page, unsigned long pfn,
> - unsigned int order)
> + unsigned int order)
> {
> if (early_page_uninitialised(pfn))
> return;
> @@ -1373,8 +1373,8 @@ void set_zone_contiguous(struct zone *zone)
>
> block_end_pfn = ALIGN(block_start_pfn + 1, pageblock_nr_pages);
> for (; block_start_pfn < zone_end_pfn(zone);
> - block_start_pfn = block_end_pfn,
> - block_end_pfn += pageblock_nr_pages) {
> + block_start_pfn = block_end_pfn,
> + block_end_pfn += pageblock_nr_pages) {
>
> block_end_pfn = min(block_end_pfn, zone_end_pfn(zone));
>
> @@ -1394,7 +1394,7 @@ void clear_zone_contiguous(struct zone *zone)
>
> #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
> static void __init deferred_free_range(struct page *page,
> - unsigned long pfn, int nr_pages)
> + unsigned long pfn, int nr_pages)
> {
> int i;
>
> @@ -1501,7 +1501,7 @@ static int __init deferred_init_memmap(void *data)
> } else {
> nr_pages += nr_to_free;
> deferred_free_range(free_base_page,
> - free_base_pfn, nr_to_free);
> + free_base_pfn, nr_to_free);
> free_base_page = NULL;
> free_base_pfn = nr_to_free = 0;
>
> @@ -1524,11 +1524,11 @@ static int __init deferred_init_memmap(void *data)
>
> /* Where possible, batch up pages for a single free */
> continue;
> -free_range:
> + free_range:
> /* Free the current block of pages to allocator */
> nr_pages += nr_to_free;
> deferred_free_range(free_base_page, free_base_pfn,
> - nr_to_free);
> + nr_to_free);
> free_base_page = NULL;
> free_base_pfn = nr_to_free = 0;
> }
> @@ -1543,7 +1543,7 @@ static int __init deferred_init_memmap(void *data)
> WARN_ON(++zid < MAX_NR_ZONES && populated_zone(++zone));
>
> pr_info("node %d initialised, %lu pages in %ums\n", nid, nr_pages,
> - jiffies_to_msecs(jiffies - start));
> + jiffies_to_msecs(jiffies - start));
>
> pgdat_init_report_one_done();
> return 0;
> @@ -1620,8 +1620,8 @@ void __init init_cma_reserved_pageblock(struct page *page)
> * -- nyc
> */
> static inline void expand(struct zone *zone, struct page *page,
> - int low, int high, struct free_area *area,
> - int migratetype)
> + int low, int high, struct free_area *area,
> + int migratetype)
> {
> unsigned long size = 1 << high;
>
> @@ -1681,7 +1681,7 @@ static void check_new_page_bad(struct page *page)
> static inline int check_new_page(struct page *page)
> {
> if (likely(page_expected_state(page,
> - PAGE_FLAGS_CHECK_AT_PREP | __PG_HWPOISON)))
> + PAGE_FLAGS_CHECK_AT_PREP | __PG_HWPOISON)))
> return 0;
>
> check_new_page_bad(page);
> @@ -1729,7 +1729,7 @@ static bool check_new_pages(struct page *page, unsigned int order)
> }
>
> inline void post_alloc_hook(struct page *page, unsigned int order,
> - gfp_t gfp_flags)
> + gfp_t gfp_flags)
> {
> set_page_private(page, 0);
> set_page_refcounted(page);
> @@ -1742,7 +1742,7 @@ inline void post_alloc_hook(struct page *page, unsigned int order,
> }
>
> static void prep_new_page(struct page *page, unsigned int order, gfp_t gfp_flags,
> - unsigned int alloc_flags)
> + unsigned int alloc_flags)
> {
> int i;
> bool poisoned = true;
> @@ -1780,7 +1780,7 @@ static void prep_new_page(struct page *page, unsigned int order, gfp_t gfp_flags
> */
> static inline
> struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
> - int migratetype)
> + int migratetype)
> {
> unsigned int current_order;
> struct free_area *area;
> @@ -1790,7 +1790,7 @@ struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
> for (current_order = order; current_order < MAX_ORDER; ++current_order) {
> area = &(zone->free_area[current_order]);
> page = list_first_entry_or_null(&area->free_list[migratetype],
> - struct page, lru);
> + struct page, lru);
> if (!page)
> continue;
> list_del(&page->lru);
> @@ -1823,13 +1823,13 @@ static int fallbacks[MIGRATE_TYPES][4] = {
>
> #ifdef CONFIG_CMA
> static struct page *__rmqueue_cma_fallback(struct zone *zone,
> - unsigned int order)
> + unsigned int order)
> {
> return __rmqueue_smallest(zone, order, MIGRATE_CMA);
> }
> #else
> static inline struct page *__rmqueue_cma_fallback(struct zone *zone,
> - unsigned int order) { return NULL; }
> + unsigned int order) { return NULL; }
> #endif
>
> /*
> @@ -1875,7 +1875,7 @@ static int move_freepages(struct zone *zone,
> * isolating, as that would be expensive.
> */
> if (num_movable &&
> - (PageLRU(page) || __PageMovable(page)))
> + (PageLRU(page) || __PageMovable(page)))
> (*num_movable)++;
>
> page++;
> @@ -1893,7 +1893,7 @@ static int move_freepages(struct zone *zone,
> }
>
> int move_freepages_block(struct zone *zone, struct page *page,
> - int migratetype, int *num_movable)
> + int migratetype, int *num_movable)
> {
> unsigned long start_pfn, end_pfn;
> struct page *start_page, *end_page;
> @@ -1911,11 +1911,11 @@ int move_freepages_block(struct zone *zone, struct page *page,
> return 0;
>
> return move_freepages(zone, start_page, end_page, migratetype,
> - num_movable);
> + num_movable);
> }
>
> static void change_pageblock_range(struct page *pageblock_page,
> - int start_order, int migratetype)
> + int start_order, int migratetype)
> {
> int nr_pageblocks = 1 << (start_order - pageblock_order);
>
> @@ -1950,9 +1950,9 @@ static bool can_steal_fallback(unsigned int order, int start_mt)
> return true;
>
> if (order >= pageblock_order / 2 ||
> - start_mt == MIGRATE_RECLAIMABLE ||
> - start_mt == MIGRATE_UNMOVABLE ||
> - page_group_by_mobility_disabled)
> + start_mt == MIGRATE_RECLAIMABLE ||
> + start_mt == MIGRATE_UNMOVABLE ||
> + page_group_by_mobility_disabled)
> return true;
>
> return false;
> @@ -1967,7 +1967,7 @@ static bool can_steal_fallback(unsigned int order, int start_mt)
> * itself, so pages freed in the future will be put on the correct free list.
> */
> static void steal_suitable_fallback(struct zone *zone, struct page *page,
> - int start_type, bool whole_block)
> + int start_type, bool whole_block)
> {
> unsigned int current_order = page_order(page);
> struct free_area *area;
> @@ -1994,7 +1994,7 @@ static void steal_suitable_fallback(struct zone *zone, struct page *page,
> goto single_page;
>
> free_pages = move_freepages_block(zone, page, start_type,
> - &movable_pages);
> + &movable_pages);
> /*
> * Determine how many pages are compatible with our allocation.
> * For movable allocation, it's the number of movable pages which
> @@ -2012,7 +2012,7 @@ static void steal_suitable_fallback(struct zone *zone, struct page *page,
> */
> if (old_block_type == MIGRATE_MOVABLE)
> alike_pages = pageblock_nr_pages
> - - (free_pages + movable_pages);
> + - (free_pages + movable_pages);
> else
> alike_pages = 0;
> }
> @@ -2022,7 +2022,7 @@ static void steal_suitable_fallback(struct zone *zone, struct page *page,
> * comparable migratability as our allocation, claim the whole block.
> */
> if (free_pages + alike_pages >= (1 << (pageblock_order - 1)) ||
> - page_group_by_mobility_disabled)
> + page_group_by_mobility_disabled)
> set_pageblock_migratetype(page, start_type);
>
> return;
> @@ -2039,7 +2039,7 @@ static void steal_suitable_fallback(struct zone *zone, struct page *page,
> * fragmentation due to mixed migratetype pages in one pageblock.
> */
> int find_suitable_fallback(struct free_area *area, unsigned int order,
> - int migratetype, bool only_stealable, bool *can_steal)
> + int migratetype, bool only_stealable, bool *can_steal)
> {
> int i;
> int fallback_mt;
> @@ -2074,7 +2074,7 @@ int find_suitable_fallback(struct free_area *area, unsigned int order,
> * there are no empty page blocks that contain a page with a suitable order
> */
> static void reserve_highatomic_pageblock(struct page *page, struct zone *zone,
> - unsigned int alloc_order)
> + unsigned int alloc_order)
> {
> int mt;
> unsigned long max_managed, flags;
> @@ -2116,7 +2116,7 @@ static void reserve_highatomic_pageblock(struct page *page, struct zone *zone,
> * pageblock is exhausted.
> */
> static bool unreserve_highatomic_pageblock(const struct alloc_context *ac,
> - bool force)
> + bool force)
> {
> struct zonelist *zonelist = ac->zonelist;
> unsigned long flags;
> @@ -2127,13 +2127,13 @@ static bool unreserve_highatomic_pageblock(const struct alloc_context *ac,
> bool ret;
>
> for_each_zone_zonelist_nodemask(zone, z, zonelist, ac->high_zoneidx,
> - ac->nodemask) {
> + ac->nodemask) {
> /*
> * Preserve at least one pageblock unless memory pressure
> * is really high.
> */
> if (!force && zone->nr_reserved_highatomic <=
> - pageblock_nr_pages)
> + pageblock_nr_pages)
> continue;
>
> spin_lock_irqsave(&zone->lock, flags);
> @@ -2141,8 +2141,8 @@ static bool unreserve_highatomic_pageblock(const struct alloc_context *ac,
> struct free_area *area = &(zone->free_area[order]);
>
> page = list_first_entry_or_null(
> - &area->free_list[MIGRATE_HIGHATOMIC],
> - struct page, lru);
> + &area->free_list[MIGRATE_HIGHATOMIC],
> + struct page, lru);
> if (!page)
> continue;
>
> @@ -2162,8 +2162,8 @@ static bool unreserve_highatomic_pageblock(const struct alloc_context *ac,
> * underflows.
> */
> zone->nr_reserved_highatomic -= min(
> - pageblock_nr_pages,
> - zone->nr_reserved_highatomic);
> + pageblock_nr_pages,
> + zone->nr_reserved_highatomic);
> }
>
> /*
> @@ -2177,7 +2177,7 @@ static bool unreserve_highatomic_pageblock(const struct alloc_context *ac,
> */
> set_pageblock_migratetype(page, ac->migratetype);
> ret = move_freepages_block(zone, page, ac->migratetype,
> - NULL);
> + NULL);
> if (ret) {
> spin_unlock_irqrestore(&zone->lock, flags);
> return ret;
> @@ -2206,22 +2206,22 @@ __rmqueue_fallback(struct zone *zone, unsigned int order, int start_migratetype)
>
> /* Find the largest possible block of pages in the other list */
> for (current_order = MAX_ORDER - 1;
> - current_order >= order && current_order <= MAX_ORDER - 1;
> - --current_order) {
> + current_order >= order && current_order <= MAX_ORDER - 1;
> + --current_order) {
> area = &(zone->free_area[current_order]);
> fallback_mt = find_suitable_fallback(area, current_order,
> - start_migratetype, false, &can_steal);
> + start_migratetype, false, &can_steal);
> if (fallback_mt == -1)
> continue;
>
> page = list_first_entry(&area->free_list[fallback_mt],
> - struct page, lru);
> + struct page, lru);
>
> steal_suitable_fallback(zone, page, start_migratetype,
> - can_steal);
> + can_steal);
>
> trace_mm_page_alloc_extfrag(page, order, current_order,
> - start_migratetype, fallback_mt);
> + start_migratetype, fallback_mt);
>
> return true;
> }
> @@ -2234,7 +2234,7 @@ __rmqueue_fallback(struct zone *zone, unsigned int order, int start_migratetype)
> * Call me with the zone->lock already held.
> */
> static struct page *__rmqueue(struct zone *zone, unsigned int order,
> - int migratetype)
> + int migratetype)
> {
> struct page *page;
>
> @@ -2508,7 +2508,7 @@ void mark_free_pages(struct zone *zone)
>
> for_each_migratetype_order(order, t) {
> list_for_each_entry(page,
> - &zone->free_area[order].free_list[t], lru) {
> + &zone->free_area[order].free_list[t], lru) {
> unsigned long i;
>
> pfn = page_to_pfn(page);
> @@ -2692,8 +2692,8 @@ static inline void zone_statistics(struct zone *preferred_zone, struct zone *z)
>
> /* Remove page from the per-cpu list, caller must protect the list */
> static struct page *__rmqueue_pcplist(struct zone *zone, int migratetype,
> - bool cold, struct per_cpu_pages *pcp,
> - struct list_head *list)
> + bool cold, struct per_cpu_pages *pcp,
> + struct list_head *list)
> {
> struct page *page;
>
> @@ -2702,8 +2702,8 @@ static struct page *__rmqueue_pcplist(struct zone *zone, int migratetype,
> do {
> if (list_empty(list)) {
> pcp->count += rmqueue_bulk(zone, 0,
> - pcp->batch, list,
> - migratetype, cold);
> + pcp->batch, list,
> + migratetype, cold);
> if (unlikely(list_empty(list)))
> return NULL;
> }
> @@ -2722,8 +2722,8 @@ static struct page *__rmqueue_pcplist(struct zone *zone, int migratetype,
>
> /* Lock and remove page from the per-cpu list */
> static struct page *rmqueue_pcplist(struct zone *preferred_zone,
> - struct zone *zone, unsigned int order,
> - gfp_t gfp_flags, int migratetype)
> + struct zone *zone, unsigned int order,
> + gfp_t gfp_flags, int migratetype)
> {
> struct per_cpu_pages *pcp;
> struct list_head *list;
> @@ -2747,16 +2747,16 @@ static struct page *rmqueue_pcplist(struct zone *preferred_zone,
> */
> static inline
> struct page *rmqueue(struct zone *preferred_zone,
> - struct zone *zone, unsigned int order,
> - gfp_t gfp_flags, unsigned int alloc_flags,
> - int migratetype)
> + struct zone *zone, unsigned int order,
> + gfp_t gfp_flags, unsigned int alloc_flags,
> + int migratetype)
> {
> unsigned long flags;
> struct page *page;
>
> if (likely(order == 0) && !in_interrupt()) {
> page = rmqueue_pcplist(preferred_zone, zone, order,
> - gfp_flags, migratetype);
> + gfp_flags, migratetype);
> goto out;
> }
>
> @@ -2826,7 +2826,7 @@ static bool should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
> if (fail_page_alloc.ignore_gfp_highmem && (gfp_mask & __GFP_HIGHMEM))
> return false;
> if (fail_page_alloc.ignore_gfp_reclaim &&
> - (gfp_mask & __GFP_DIRECT_RECLAIM))
> + (gfp_mask & __GFP_DIRECT_RECLAIM))
> return false;
>
> return should_fail(&fail_page_alloc.attr, 1 << order);
> @@ -2845,10 +2845,10 @@ static int __init fail_page_alloc_debugfs(void)
> return PTR_ERR(dir);
>
> if (!debugfs_create_bool("ignore-gfp-wait", mode, dir,
> - &fail_page_alloc.ignore_gfp_reclaim))
> + &fail_page_alloc.ignore_gfp_reclaim))
> goto fail;
> if (!debugfs_create_bool("ignore-gfp-highmem", mode, dir,
> - &fail_page_alloc.ignore_gfp_highmem))
> + &fail_page_alloc.ignore_gfp_highmem))
> goto fail;
> if (!debugfs_create_u32("min-order", mode, dir,
> &fail_page_alloc.min_order))
> @@ -2949,14 +2949,14 @@ bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
> }
>
> bool zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
> - int classzone_idx, unsigned int alloc_flags)
> + int classzone_idx, unsigned int alloc_flags)
> {
> return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags,
> - zone_page_state(z, NR_FREE_PAGES));
> + zone_page_state(z, NR_FREE_PAGES));
> }
>
> static inline bool zone_watermark_fast(struct zone *z, unsigned int order,
> - unsigned long mark, int classzone_idx, unsigned int alloc_flags)
> + unsigned long mark, int classzone_idx, unsigned int alloc_flags)
> {
> long free_pages = zone_page_state(z, NR_FREE_PAGES);
> long cma_pages = 0;
> @@ -2978,11 +2978,11 @@ static inline bool zone_watermark_fast(struct zone *z, unsigned int order,
> return true;
>
> return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags,
> - free_pages);
> + free_pages);
> }
>
> bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
> - unsigned long mark, int classzone_idx)
> + unsigned long mark, int classzone_idx)
> {
> long free_pages = zone_page_state(z, NR_FREE_PAGES);
>
> @@ -2990,14 +2990,14 @@ bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
> free_pages = zone_page_state_snapshot(z, NR_FREE_PAGES);
>
> return __zone_watermark_ok(z, order, mark, classzone_idx, 0,
> - free_pages);
> + free_pages);
> }
>
> #ifdef CONFIG_NUMA
> static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
> {
> return node_distance(zone_to_nid(local_zone), zone_to_nid(zone)) <=
> - RECLAIM_DISTANCE;
> + RECLAIM_DISTANCE;
> }
> #else /* CONFIG_NUMA */
> static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
> @@ -3012,7 +3012,7 @@ static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
> */
> static struct page *
> get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
> - const struct alloc_context *ac)
> + const struct alloc_context *ac)
> {
> struct zoneref *z = ac->preferred_zoneref;
> struct zone *zone;
> @@ -3023,14 +3023,14 @@ get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
> * See also __cpuset_node_allowed() comment in kernel/cpuset.c.
> */
> for_next_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
> - ac->nodemask) {
> + ac->nodemask) {
> struct page *page;
> unsigned long mark;
>
> if (cpusets_enabled() &&
> - (alloc_flags & ALLOC_CPUSET) &&
> - !__cpuset_zone_allowed(zone, gfp_mask))
> - continue;
> + (alloc_flags & ALLOC_CPUSET) &&
> + !__cpuset_zone_allowed(zone, gfp_mask))
> + continue;
> /*
> * When allocating a page cache page for writing, we
> * want to get it from a node that is within its dirty
> @@ -3062,7 +3062,7 @@ get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
>
> mark = zone->watermark[alloc_flags & ALLOC_WMARK_MASK];
> if (!zone_watermark_fast(zone, order, mark,
> - ac_classzone_idx(ac), alloc_flags)) {
> + ac_classzone_idx(ac), alloc_flags)) {
> int ret;
>
> /* Checked here to keep the fast path fast */
> @@ -3085,16 +3085,16 @@ get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
> default:
> /* did we reclaim enough */
> if (zone_watermark_ok(zone, order, mark,
> - ac_classzone_idx(ac), alloc_flags))
> + ac_classzone_idx(ac), alloc_flags))
> goto try_this_zone;
>
> continue;
> }
> }
>
> -try_this_zone:
> + try_this_zone:
> page = rmqueue(ac->preferred_zoneref->zone, zone, order,
> - gfp_mask, alloc_flags, ac->migratetype);
> + gfp_mask, alloc_flags, ac->migratetype);
> if (page) {
> prep_new_page(page, order, gfp_mask, alloc_flags);
>
> @@ -3188,21 +3188,21 @@ __alloc_pages_cpuset_fallback(gfp_t gfp_mask, unsigned int order,
> struct page *page;
>
> page = get_page_from_freelist(gfp_mask, order,
> - alloc_flags | ALLOC_CPUSET, ac);
> + alloc_flags | ALLOC_CPUSET, ac);
> /*
> * fallback to ignore cpuset restriction if our nodes
> * are depleted
> */
> if (!page)
> page = get_page_from_freelist(gfp_mask, order,
> - alloc_flags, ac);
> + alloc_flags, ac);
>
> return page;
> }
>
> static inline struct page *
> __alloc_pages_may_oom(gfp_t gfp_mask, unsigned int order,
> - const struct alloc_context *ac, unsigned long *did_some_progress)
> + const struct alloc_context *ac, unsigned long *did_some_progress)
> {
> struct oom_control oc = {
> .zonelist = ac->zonelist,
> @@ -3231,7 +3231,7 @@ __alloc_pages_may_oom(gfp_t gfp_mask, unsigned int order,
> * we're still under heavy pressure.
> */
> page = get_page_from_freelist(gfp_mask | __GFP_HARDWALL, order,
> - ALLOC_WMARK_HIGH | ALLOC_CPUSET, ac);
> + ALLOC_WMARK_HIGH | ALLOC_CPUSET, ac);
> if (page)
> goto out;
>
> @@ -3270,7 +3270,7 @@ __alloc_pages_may_oom(gfp_t gfp_mask, unsigned int order,
> */
> if (gfp_mask & __GFP_NOFAIL)
> page = __alloc_pages_cpuset_fallback(gfp_mask, order,
> - ALLOC_NO_WATERMARKS, ac);
> + ALLOC_NO_WATERMARKS, ac);
> }
> out:
> mutex_unlock(&oom_lock);
> @@ -3287,8 +3287,8 @@ __alloc_pages_may_oom(gfp_t gfp_mask, unsigned int order,
> /* Try memory compaction for high-order allocations before reclaim */
> static struct page *
> __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
> - unsigned int alloc_flags, const struct alloc_context *ac,
> - enum compact_priority prio, enum compact_result *compact_result)
> + unsigned int alloc_flags, const struct alloc_context *ac,
> + enum compact_priority prio, enum compact_result *compact_result)
> {
> struct page *page;
>
> @@ -3297,7 +3297,7 @@ __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
>
> current->flags |= PF_MEMALLOC;
> *compact_result = try_to_compact_pages(gfp_mask, order, alloc_flags, ac,
> - prio);
> + prio);
> current->flags &= ~PF_MEMALLOC;
>
> if (*compact_result <= COMPACT_INACTIVE)
> @@ -3389,7 +3389,7 @@ should_compact_retry(struct alloc_context *ac, int order, int alloc_flags,
> */
> check_priority:
> min_priority = (order > PAGE_ALLOC_COSTLY_ORDER) ?
> - MIN_COMPACT_COSTLY_PRIORITY : MIN_COMPACT_PRIORITY;
> + MIN_COMPACT_COSTLY_PRIORITY : MIN_COMPACT_PRIORITY;
>
> if (*compact_priority > min_priority) {
> (*compact_priority)--;
> @@ -3403,8 +3403,8 @@ should_compact_retry(struct alloc_context *ac, int order, int alloc_flags,
> #else
> static inline struct page *
> __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
> - unsigned int alloc_flags, const struct alloc_context *ac,
> - enum compact_priority prio, enum compact_result *compact_result)
> + unsigned int alloc_flags, const struct alloc_context *ac,
> + enum compact_priority prio, enum compact_result *compact_result)
> {
> *compact_result = COMPACT_SKIPPED;
> return NULL;
> @@ -3431,7 +3431,7 @@ should_compact_retry(struct alloc_context *ac, unsigned int order, int alloc_fla
> for_each_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
> ac->nodemask) {
> if (zone_watermark_ok(zone, 0, min_wmark_pages(zone),
> - ac_classzone_idx(ac), alloc_flags))
> + ac_classzone_idx(ac), alloc_flags))
> return true;
> }
> return false;
> @@ -3441,7 +3441,7 @@ should_compact_retry(struct alloc_context *ac, unsigned int order, int alloc_fla
> /* Perform direct synchronous page reclaim */
> static int
> __perform_reclaim(gfp_t gfp_mask, unsigned int order,
> - const struct alloc_context *ac)
> + const struct alloc_context *ac)
> {
> struct reclaim_state reclaim_state;
> int progress;
> @@ -3456,7 +3456,7 @@ __perform_reclaim(gfp_t gfp_mask, unsigned int order,
> current->reclaim_state = &reclaim_state;
>
> progress = try_to_free_pages(ac->zonelist, order, gfp_mask,
> - ac->nodemask);
> + ac->nodemask);
>
> current->reclaim_state = NULL;
> lockdep_clear_current_reclaim_state();
> @@ -3470,8 +3470,8 @@ __perform_reclaim(gfp_t gfp_mask, unsigned int order,
> /* The really slow allocator path where we enter direct reclaim */
> static inline struct page *
> __alloc_pages_direct_reclaim(gfp_t gfp_mask, unsigned int order,
> - unsigned int alloc_flags, const struct alloc_context *ac,
> - unsigned long *did_some_progress)
> + unsigned int alloc_flags, const struct alloc_context *ac,
> + unsigned long *did_some_progress)
> {
> struct page *page = NULL;
> bool drained = false;
> @@ -3560,8 +3560,8 @@ bool gfp_pfmemalloc_allowed(gfp_t gfp_mask)
> if (in_serving_softirq() && (current->flags & PF_MEMALLOC))
> return true;
> if (!in_interrupt() &&
> - ((current->flags & PF_MEMALLOC) ||
> - unlikely(test_thread_flag(TIF_MEMDIE))))
> + ((current->flags & PF_MEMALLOC) ||
> + unlikely(test_thread_flag(TIF_MEMDIE))))
> return true;
>
> return false;
> @@ -3625,9 +3625,9 @@ should_reclaim_retry(gfp_t gfp_mask, unsigned order,
> * reclaimable pages?
> */
> wmark = __zone_watermark_ok(zone, order, min_wmark,
> - ac_classzone_idx(ac), alloc_flags, available);
> + ac_classzone_idx(ac), alloc_flags, available);
> trace_reclaim_retry_zone(z, order, reclaimable,
> - available, min_wmark, *no_progress_loops, wmark);
> + available, min_wmark, *no_progress_loops, wmark);
> if (wmark) {
> /*
> * If we didn't make any progress and have a lot of
> @@ -3639,7 +3639,7 @@ should_reclaim_retry(gfp_t gfp_mask, unsigned order,
> unsigned long write_pending;
>
> write_pending = zone_page_state_snapshot(zone,
> - NR_ZONE_WRITE_PENDING);
> + NR_ZONE_WRITE_PENDING);
>
> if (2 * write_pending > reclaimable) {
> congestion_wait(BLK_RW_ASYNC, HZ / 10);
> @@ -3670,7 +3670,7 @@ should_reclaim_retry(gfp_t gfp_mask, unsigned order,
>
> static inline struct page *
> __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
> - struct alloc_context *ac)
> + struct alloc_context *ac)
> {
> bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;
> const bool costly_order = order > PAGE_ALLOC_COSTLY_ORDER;
> @@ -3701,7 +3701,7 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
> * callers that are not in atomic context.
> */
> if (WARN_ON_ONCE((gfp_mask & (__GFP_ATOMIC | __GFP_DIRECT_RECLAIM)) ==
> - (__GFP_ATOMIC | __GFP_DIRECT_RECLAIM)))
> + (__GFP_ATOMIC | __GFP_DIRECT_RECLAIM)))
> gfp_mask &= ~__GFP_ATOMIC;
>
> retry_cpuset:
> @@ -3724,7 +3724,7 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
> * could end up iterating over non-eligible zones endlessly.
> */
> ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
> - ac->high_zoneidx, ac->nodemask);
> + ac->high_zoneidx, ac->nodemask);
> if (!ac->preferred_zoneref->zone)
> goto nopage;
>
> @@ -3749,13 +3749,13 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
> * watermarks, as the ALLOC_NO_WATERMARKS attempt didn't yet happen.
> */
> if (can_direct_reclaim &&
> - (costly_order ||
> - (order > 0 && ac->migratetype != MIGRATE_MOVABLE))
> - && !gfp_pfmemalloc_allowed(gfp_mask)) {
> + (costly_order ||
> + (order > 0 && ac->migratetype != MIGRATE_MOVABLE))
> + && !gfp_pfmemalloc_allowed(gfp_mask)) {
> page = __alloc_pages_direct_compact(gfp_mask, order,
> - alloc_flags, ac,
> - INIT_COMPACT_PRIORITY,
> - &compact_result);
> + alloc_flags, ac,
> + INIT_COMPACT_PRIORITY,
> + &compact_result);
> if (page)
> goto got_pg;
>
> @@ -3800,7 +3800,7 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
> if (!(alloc_flags & ALLOC_CPUSET) || (alloc_flags & ALLOC_NO_WATERMARKS)) {
> ac->zonelist = node_zonelist(numa_node_id(), gfp_mask);
> ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
> - ac->high_zoneidx, ac->nodemask);
> + ac->high_zoneidx, ac->nodemask);
> }
>
> /* Attempt with potentially adjusted zonelist and alloc_flags */
> @@ -3815,8 +3815,8 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
> /* Make sure we know about allocations which stall for too long */
> if (time_after(jiffies, alloc_start + stall_timeout)) {
> warn_alloc(gfp_mask & ~__GFP_NOWARN, ac->nodemask,
> - "page allocation stalls for %ums, order:%u",
> - jiffies_to_msecs(jiffies - alloc_start), order);
> + "page allocation stalls for %ums, order:%u",
> + jiffies_to_msecs(jiffies - alloc_start), order);
> stall_timeout += 10 * HZ;
> }
>
> @@ -3826,13 +3826,13 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
>
> /* Try direct reclaim and then allocating */
> page = __alloc_pages_direct_reclaim(gfp_mask, order, alloc_flags, ac,
> - &did_some_progress);
> + &did_some_progress);
> if (page)
> goto got_pg;
>
> /* Try direct compaction and then allocating */
> page = __alloc_pages_direct_compact(gfp_mask, order, alloc_flags, ac,
> - compact_priority, &compact_result);
> + compact_priority, &compact_result);
> if (page)
> goto got_pg;
>
> @@ -3858,9 +3858,9 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
> * of free memory (see __compaction_suitable)
> */
> if (did_some_progress > 0 &&
> - should_compact_retry(ac, order, alloc_flags,
> - compact_result, &compact_priority,
> - &compaction_retries))
> + should_compact_retry(ac, order, alloc_flags,
> + compact_result, &compact_priority,
> + &compaction_retries))
> goto retry;
>
> /*
> @@ -3938,15 +3938,15 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
> }
> fail:
> warn_alloc(gfp_mask, ac->nodemask,
> - "page allocation failure: order:%u", order);
> + "page allocation failure: order:%u", order);
> got_pg:
> return page;
> }
>
> static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,
> - struct zonelist *zonelist, nodemask_t *nodemask,
> - struct alloc_context *ac, gfp_t *alloc_mask,
> - unsigned int *alloc_flags)
> + struct zonelist *zonelist, nodemask_t *nodemask,
> + struct alloc_context *ac, gfp_t *alloc_mask,
> + unsigned int *alloc_flags)
> {
> ac->high_zoneidx = gfp_zone(gfp_mask);
> ac->zonelist = zonelist;
> @@ -3976,7 +3976,7 @@ static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,
>
> /* Determine whether to spread dirty pages and what the first usable zone */
> static inline void finalise_ac(gfp_t gfp_mask,
> - unsigned int order, struct alloc_context *ac)
> + unsigned int order, struct alloc_context *ac)
> {
> /* Dirty zone balancing only done in the fast path */
> ac->spread_dirty_pages = (gfp_mask & __GFP_WRITE);
> @@ -3987,7 +3987,7 @@ static inline void finalise_ac(gfp_t gfp_mask,
> * may get reset for allocations that ignore memory policies.
> */
> ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
> - ac->high_zoneidx, ac->nodemask);
> + ac->high_zoneidx, ac->nodemask);
> }
>
> /*
> @@ -3995,7 +3995,7 @@ static inline void finalise_ac(gfp_t gfp_mask,
> */
> struct page *
> __alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
> - struct zonelist *zonelist, nodemask_t *nodemask)
> + struct zonelist *zonelist, nodemask_t *nodemask)
> {
> struct page *page;
> unsigned int alloc_flags = ALLOC_WMARK_LOW;
> @@ -4114,7 +4114,7 @@ static struct page *__page_frag_cache_refill(struct page_frag_cache *nc,
>
> #if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
> gfp_mask |= __GFP_COMP | __GFP_NOWARN | __GFP_NORETRY |
> - __GFP_NOMEMALLOC;
> + __GFP_NOMEMALLOC;
> page = alloc_pages_node(NUMA_NO_NODE, gfp_mask,
> PAGE_FRAG_CACHE_MAX_ORDER);
> nc->size = page ? PAGE_FRAG_CACHE_MAX_SIZE : PAGE_SIZE;
> @@ -4150,7 +4150,7 @@ void *page_frag_alloc(struct page_frag_cache *nc,
> int offset;
>
> if (unlikely(!nc->va)) {
> -refill:
> + refill:
> page = __page_frag_cache_refill(nc, gfp_mask);
> if (!page)
> return NULL;
> @@ -4209,7 +4209,7 @@ void page_frag_free(void *addr)
> EXPORT_SYMBOL(page_frag_free);
>
> static void *make_alloc_exact(unsigned long addr, unsigned int order,
> - size_t size)
> + size_t size)
> {
> if (addr) {
> unsigned long alloc_end = addr + (PAGE_SIZE << order);
> @@ -4378,7 +4378,7 @@ long si_mem_available(void)
> * and cannot be freed. Cap this estimate at the low watermark.
> */
> available += global_page_state(NR_SLAB_RECLAIMABLE) -
> - min(global_page_state(NR_SLAB_RECLAIMABLE) / 2, wmark_low);
> + min(global_page_state(NR_SLAB_RECLAIMABLE) / 2, wmark_low);
>
> if (available < 0)
> available = 0;
> @@ -4714,7 +4714,7 @@ static int build_zonelists_node(pg_data_t *pgdat, struct zonelist *zonelist,
> zone = pgdat->node_zones + zone_type;
> if (managed_zone(zone)) {
> zoneref_set_zone(zone,
> - &zonelist->_zonerefs[nr_zones++]);
> + &zonelist->_zonerefs[nr_zones++]);
> check_highest_zone(zone_type);
> }
> } while (zone_type);
> @@ -4792,8 +4792,8 @@ early_param("numa_zonelist_order", setup_numa_zonelist_order);
> * sysctl handler for numa_zonelist_order
> */
> int numa_zonelist_order_handler(struct ctl_table *table, int write,
> - void __user *buffer, size_t *length,
> - loff_t *ppos)
> + void __user *buffer, size_t *length,
> + loff_t *ppos)
> {
> char saved_string[NUMA_ZONELIST_ORDER_LEN];
> int ret;
> @@ -4952,7 +4952,7 @@ static void build_zonelists_in_zone_order(pg_data_t *pgdat, int nr_nodes)
> z = &NODE_DATA(node)->node_zones[zone_type];
> if (managed_zone(z)) {
> zoneref_set_zone(z,
> - &zonelist->_zonerefs[pos++]);
> + &zonelist->_zonerefs[pos++]);
> check_highest_zone(zone_type);
> }
> }
> @@ -5056,8 +5056,8 @@ int local_memory_node(int node)
> struct zoneref *z;
>
> z = first_zones_zonelist(node_zonelist(node, GFP_KERNEL),
> - gfp_zone(GFP_KERNEL),
> - NULL);
> + gfp_zone(GFP_KERNEL),
> + NULL);
> return z->zone->node;
> }
> #endif
> @@ -5248,7 +5248,7 @@ void __ref build_all_zonelists(pg_data_t *pgdat, struct zone *zone)
> * done. Non-atomic initialization, single-pass.
> */
> void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
> - unsigned long start_pfn, enum memmap_context context)
> + unsigned long start_pfn, enum memmap_context context)
> {
> struct vmem_altmap *altmap = to_vmem_altmap(__pfn_to_phys(start_pfn));
> unsigned long end_pfn = start_pfn + size;
> @@ -5315,7 +5315,7 @@ void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
> }
> #endif
>
> -not_early:
> + not_early:
> /*
> * Mark the block movable so that blocks are reserved for
> * movable at startup. This will force kernel allocations
> @@ -5349,7 +5349,7 @@ static void __meminit zone_init_free_lists(struct zone *zone)
> }
>
> #ifndef __HAVE_ARCH_MEMMAP_INIT
> -#define memmap_init(size, nid, zone, start_pfn) \
> +#define memmap_init(size, nid, zone, start_pfn) \
> memmap_init_zone((size), (nid), (zone), (start_pfn), MEMMAP_EARLY)
> #endif
>
> @@ -5417,13 +5417,13 @@ static int zone_batchsize(struct zone *zone)
> * exist).
> */
> static void pageset_update(struct per_cpu_pages *pcp, unsigned long high,
> - unsigned long batch)
> + unsigned long batch)
> {
> - /* start with a fail safe value for batch */
> + /* start with a fail safe value for batch */
> pcp->batch = 1;
> smp_wmb();
>
> - /* Update high, then batch, in order */
> + /* Update high, then batch, in order */
> pcp->high = high;
> smp_wmb();
>
> @@ -5460,7 +5460,7 @@ static void setup_pageset(struct per_cpu_pageset *p, unsigned long batch)
> * to the value high for the pageset p.
> */
> static void pageset_set_high(struct per_cpu_pageset *p,
> - unsigned long high)
> + unsigned long high)
> {
> unsigned long batch = max(1UL, high / 4);
> if ((high / 4) > (PAGE_SHIFT * 8))
> @@ -5474,8 +5474,8 @@ static void pageset_set_high_and_batch(struct zone *zone,
> {
> if (percpu_pagelist_fraction)
> pageset_set_high(pcp,
> - (zone->managed_pages /
> - percpu_pagelist_fraction));
> + (zone->managed_pages /
> + percpu_pagelist_fraction));
> else
> pageset_set_batch(pcp, zone_batchsize(zone));
> }
> @@ -5510,7 +5510,7 @@ void __init setup_per_cpu_pageset(void)
>
> for_each_online_pgdat(pgdat)
> pgdat->per_cpu_nodestats =
> - alloc_percpu(struct per_cpu_nodestat);
> + alloc_percpu(struct per_cpu_nodestat);
> }
>
> static __meminit void zone_pcp_init(struct zone *zone)
> @@ -5538,10 +5538,10 @@ int __meminit init_currently_empty_zone(struct zone *zone,
> zone->zone_start_pfn = zone_start_pfn;
>
> mminit_dprintk(MMINIT_TRACE, "memmap_init",
> - "Initialising map node %d zone %lu pfns %lu -> %lu\n",
> - pgdat->node_id,
> - (unsigned long)zone_idx(zone),
> - zone_start_pfn, (zone_start_pfn + size));
> + "Initialising map node %d zone %lu pfns %lu -> %lu\n",
> + pgdat->node_id,
> + (unsigned long)zone_idx(zone),
> + zone_start_pfn, (zone_start_pfn + size));
>
> zone_init_free_lists(zone);
> zone->initialized = 1;
> @@ -5556,7 +5556,7 @@ int __meminit init_currently_empty_zone(struct zone *zone,
> * Required by SPARSEMEM. Given a PFN, return what node the PFN is on.
> */
> int __meminit __early_pfn_to_nid(unsigned long pfn,
> - struct mminit_pfnnid_cache *state)
> + struct mminit_pfnnid_cache *state)
> {
> unsigned long start_pfn, end_pfn;
> int nid;
> @@ -5595,8 +5595,8 @@ void __init free_bootmem_with_active_regions(int nid, unsigned long max_low_pfn)
>
> if (start_pfn < end_pfn)
> memblock_free_early_nid(PFN_PHYS(start_pfn),
> - (end_pfn - start_pfn) << PAGE_SHIFT,
> - this_nid);
> + (end_pfn - start_pfn) << PAGE_SHIFT,
> + this_nid);
> }
> }
>
> @@ -5628,7 +5628,7 @@ void __init sparse_memory_present_with_active_regions(int nid)
> * PFNs will be 0.
> */
> void __meminit get_pfn_range_for_nid(unsigned int nid,
> - unsigned long *start_pfn, unsigned long *end_pfn)
> + unsigned long *start_pfn, unsigned long *end_pfn)
> {
> unsigned long this_start_pfn, this_end_pfn;
> int i;
> @@ -5658,7 +5658,7 @@ static void __init find_usable_zone_for_movable(void)
> continue;
>
> if (arch_zone_highest_possible_pfn[zone_index] >
> - arch_zone_lowest_possible_pfn[zone_index])
> + arch_zone_lowest_possible_pfn[zone_index])
> break;
> }
>
> @@ -5677,11 +5677,11 @@ static void __init find_usable_zone_for_movable(void)
> * zones within a node are in order of monotonic increases memory addresses
> */
> static void __meminit adjust_zone_range_for_zone_movable(int nid,
> - unsigned long zone_type,
> - unsigned long node_start_pfn,
> - unsigned long node_end_pfn,
> - unsigned long *zone_start_pfn,
> - unsigned long *zone_end_pfn)
> + unsigned long zone_type,
> + unsigned long node_start_pfn,
> + unsigned long node_end_pfn,
> + unsigned long *zone_start_pfn,
> + unsigned long *zone_end_pfn)
> {
> /* Only adjust if ZONE_MOVABLE is on this node */
> if (zone_movable_pfn[nid]) {
> @@ -5689,15 +5689,15 @@ static void __meminit adjust_zone_range_for_zone_movable(int nid,
> if (zone_type == ZONE_MOVABLE) {
> *zone_start_pfn = zone_movable_pfn[nid];
> *zone_end_pfn = min(node_end_pfn,
> - arch_zone_highest_possible_pfn[movable_zone]);
> + arch_zone_highest_possible_pfn[movable_zone]);
>
> - /* Adjust for ZONE_MOVABLE starting within this range */
> + /* Adjust for ZONE_MOVABLE starting within this range */
> } else if (!mirrored_kernelcore &&
> - *zone_start_pfn < zone_movable_pfn[nid] &&
> - *zone_end_pfn > zone_movable_pfn[nid]) {
> + *zone_start_pfn < zone_movable_pfn[nid] &&
> + *zone_end_pfn > zone_movable_pfn[nid]) {
> *zone_end_pfn = zone_movable_pfn[nid];
>
> - /* Check if this whole range is within ZONE_MOVABLE */
> + /* Check if this whole range is within ZONE_MOVABLE */
> } else if (*zone_start_pfn >= zone_movable_pfn[nid])
> *zone_start_pfn = *zone_end_pfn;
> }
> @@ -5708,12 +5708,12 @@ static void __meminit adjust_zone_range_for_zone_movable(int nid,
> * present_pages = zone_spanned_pages_in_node() - zone_absent_pages_in_node()
> */
> static unsigned long __meminit zone_spanned_pages_in_node(int nid,
> - unsigned long zone_type,
> - unsigned long node_start_pfn,
> - unsigned long node_end_pfn,
> - unsigned long *zone_start_pfn,
> - unsigned long *zone_end_pfn,
> - unsigned long *ignored)
> + unsigned long zone_type,
> + unsigned long node_start_pfn,
> + unsigned long node_end_pfn,
> + unsigned long *zone_start_pfn,
> + unsigned long *zone_end_pfn,
> + unsigned long *ignored)
> {
> /* When hotadd a new node from cpu_up(), the node should be empty */
> if (!node_start_pfn && !node_end_pfn)
> @@ -5723,8 +5723,8 @@ static unsigned long __meminit zone_spanned_pages_in_node(int nid,
> *zone_start_pfn = arch_zone_lowest_possible_pfn[zone_type];
> *zone_end_pfn = arch_zone_highest_possible_pfn[zone_type];
> adjust_zone_range_for_zone_movable(nid, zone_type,
> - node_start_pfn, node_end_pfn,
> - zone_start_pfn, zone_end_pfn);
> + node_start_pfn, node_end_pfn,
> + zone_start_pfn, zone_end_pfn);
>
> /* Check that this node has pages within the zone's required range */
> if (*zone_end_pfn < node_start_pfn || *zone_start_pfn > node_end_pfn)
> @@ -5743,8 +5743,8 @@ static unsigned long __meminit zone_spanned_pages_in_node(int nid,
> * then all holes in the requested range will be accounted for.
> */
> unsigned long __meminit __absent_pages_in_range(int nid,
> - unsigned long range_start_pfn,
> - unsigned long range_end_pfn)
> + unsigned long range_start_pfn,
> + unsigned long range_end_pfn)
> {
> unsigned long nr_absent = range_end_pfn - range_start_pfn;
> unsigned long start_pfn, end_pfn;
> @@ -5766,17 +5766,17 @@ unsigned long __meminit __absent_pages_in_range(int nid,
> * It returns the number of pages frames in memory holes within a range.
> */
> unsigned long __init absent_pages_in_range(unsigned long start_pfn,
> - unsigned long end_pfn)
> + unsigned long end_pfn)
> {
> return __absent_pages_in_range(MAX_NUMNODES, start_pfn, end_pfn);
> }
>
> /* Return the number of page frames in holes in a zone on a node */
> static unsigned long __meminit zone_absent_pages_in_node(int nid,
> - unsigned long zone_type,
> - unsigned long node_start_pfn,
> - unsigned long node_end_pfn,
> - unsigned long *ignored)
> + unsigned long zone_type,
> + unsigned long node_start_pfn,
> + unsigned long node_end_pfn,
> + unsigned long *ignored)
> {
> unsigned long zone_low = arch_zone_lowest_possible_pfn[zone_type];
> unsigned long zone_high = arch_zone_highest_possible_pfn[zone_type];
> @@ -5791,8 +5791,8 @@ static unsigned long __meminit zone_absent_pages_in_node(int nid,
> zone_end_pfn = clamp(node_end_pfn, zone_low, zone_high);
>
> adjust_zone_range_for_zone_movable(nid, zone_type,
> - node_start_pfn, node_end_pfn,
> - &zone_start_pfn, &zone_end_pfn);
> + node_start_pfn, node_end_pfn,
> + &zone_start_pfn, &zone_end_pfn);
>
> /* If this node has no page within this zone, return 0. */
> if (zone_start_pfn == zone_end_pfn)
> @@ -5830,12 +5830,12 @@ static unsigned long __meminit zone_absent_pages_in_node(int nid,
>
> #else /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
> static inline unsigned long __meminit zone_spanned_pages_in_node(int nid,
> - unsigned long zone_type,
> - unsigned long node_start_pfn,
> - unsigned long node_end_pfn,
> - unsigned long *zone_start_pfn,
> - unsigned long *zone_end_pfn,
> - unsigned long *zones_size)
> + unsigned long zone_type,
> + unsigned long node_start_pfn,
> + unsigned long node_end_pfn,
> + unsigned long *zone_start_pfn,
> + unsigned long *zone_end_pfn,
> + unsigned long *zones_size)
> {
> unsigned int zone;
>
> @@ -5849,10 +5849,10 @@ static inline unsigned long __meminit zone_spanned_pages_in_node(int nid,
> }
>
> static inline unsigned long __meminit zone_absent_pages_in_node(int nid,
> - unsigned long zone_type,
> - unsigned long node_start_pfn,
> - unsigned long node_end_pfn,
> - unsigned long *zholes_size)
> + unsigned long zone_type,
> + unsigned long node_start_pfn,
> + unsigned long node_end_pfn,
> + unsigned long *zholes_size)
> {
> if (!zholes_size)
> return 0;
> @@ -5883,8 +5883,8 @@ static void __meminit calculate_node_totalpages(struct pglist_data *pgdat,
> &zone_end_pfn,
> zones_size);
> real_size = size - zone_absent_pages_in_node(pgdat->node_id, i,
> - node_start_pfn, node_end_pfn,
> - zholes_size);
> + node_start_pfn, node_end_pfn,
> + zholes_size);
> if (size)
> zone->zone_start_pfn = zone_start_pfn;
> else
> @@ -6143,7 +6143,7 @@ static void __ref alloc_node_mem_map(struct pglist_data *pgdat)
> }
>
> void __paginginit free_area_init_node(int nid, unsigned long *zones_size,
> - unsigned long node_start_pfn, unsigned long *zholes_size)
> + unsigned long node_start_pfn, unsigned long *zholes_size)
> {
> pg_data_t *pgdat = NODE_DATA(nid);
> unsigned long start_pfn = 0;
> @@ -6428,12 +6428,12 @@ static void __init find_zone_movable_pfns_for_nodes(void)
> if (start_pfn < usable_startpfn) {
> unsigned long kernel_pages;
> kernel_pages = min(end_pfn, usable_startpfn)
> - - start_pfn;
> + - start_pfn;
>
> kernelcore_remaining -= min(kernel_pages,
> - kernelcore_remaining);
> + kernelcore_remaining);
> required_kernelcore -= min(kernel_pages,
> - required_kernelcore);
> + required_kernelcore);
>
> /* Continue if range is now fully accounted */
> if (end_pfn <= usable_startpfn) {
> @@ -6466,7 +6466,7 @@ static void __init find_zone_movable_pfns_for_nodes(void)
> * satisfied
> */
> required_kernelcore -= min(required_kernelcore,
> - size_pages);
> + size_pages);
> kernelcore_remaining -= size_pages;
> if (!kernelcore_remaining)
> break;
> @@ -6534,9 +6534,9 @@ void __init free_area_init_nodes(unsigned long *max_zone_pfn)
>
> /* Record where the zone boundaries are */
> memset(arch_zone_lowest_possible_pfn, 0,
> - sizeof(arch_zone_lowest_possible_pfn));
> + sizeof(arch_zone_lowest_possible_pfn));
> memset(arch_zone_highest_possible_pfn, 0,
> - sizeof(arch_zone_highest_possible_pfn));
> + sizeof(arch_zone_highest_possible_pfn));
>
> start_pfn = find_min_pfn_with_active_regions();
>
> @@ -6562,14 +6562,14 @@ void __init free_area_init_nodes(unsigned long *max_zone_pfn)
> continue;
> pr_info(" %-8s ", zone_names[i]);
> if (arch_zone_lowest_possible_pfn[i] ==
> - arch_zone_highest_possible_pfn[i])
> + arch_zone_highest_possible_pfn[i])
> pr_cont("empty\n");
> else
> pr_cont("[mem %#018Lx-%#018Lx]\n",
> (u64)arch_zone_lowest_possible_pfn[i]
> - << PAGE_SHIFT,
> + << PAGE_SHIFT,
> ((u64)arch_zone_highest_possible_pfn[i]
> - << PAGE_SHIFT) - 1);
> + << PAGE_SHIFT) - 1);
> }
>
> /* Print out the PFNs ZONE_MOVABLE begins at in each node */
> @@ -6577,7 +6577,7 @@ void __init free_area_init_nodes(unsigned long *max_zone_pfn)
> for (i = 0; i < MAX_NUMNODES; i++) {
> if (zone_movable_pfn[i])
> pr_info(" Node %d: %#018Lx\n", i,
> - (u64)zone_movable_pfn[i] << PAGE_SHIFT);
> + (u64)zone_movable_pfn[i] << PAGE_SHIFT);
> }
>
> /* Print out the early node map */
> @@ -6593,7 +6593,7 @@ void __init free_area_init_nodes(unsigned long *max_zone_pfn)
> for_each_online_node(nid) {
> pg_data_t *pgdat = NODE_DATA(nid);
> free_area_init_node(nid, NULL,
> - find_min_pfn_for_node(nid), NULL);
> + find_min_pfn_for_node(nid), NULL);
>
> /* Any memory on that node */
> if (pgdat->node_present_pages)
> @@ -6711,14 +6711,14 @@ void __init mem_init_print_info(const char *str)
> * please refer to arch/tile/kernel/vmlinux.lds.S.
> * 3) .rodata.* may be embedded into .text or .data sections.
> */
> -#define adj_init_size(start, end, size, pos, adj) \
> - do { \
> - if (start <= pos && pos < end && size > adj) \
> - size -= adj; \
> +#define adj_init_size(start, end, size, pos, adj) \
> + do { \
> + if (start <= pos && pos < end && size > adj) \
> + size -= adj; \
> } while (0)
>
> adj_init_size(__init_begin, __init_end, init_data_size,
> - _sinittext, init_code_size);
> + _sinittext, init_code_size);
> adj_init_size(_stext, _etext, codesize, _sinittext, init_code_size);
> adj_init_size(_sdata, _edata, datasize, __init_begin, init_data_size);
> adj_init_size(_stext, _etext, codesize, __start_rodata, rosize);
> @@ -6762,7 +6762,7 @@ void __init set_dma_reserve(unsigned long new_dma_reserve)
> void __init free_area_init(unsigned long *zones_size)
> {
> free_area_init_node(0, zones_size,
> - __pa(PAGE_OFFSET) >> PAGE_SHIFT, NULL);
> + __pa(PAGE_OFFSET) >> PAGE_SHIFT, NULL);
> }
>
> static int page_alloc_cpu_dead(unsigned int cpu)
> @@ -6992,7 +6992,7 @@ int __meminit init_per_zone_wmark_min(void)
> min_free_kbytes = 65536;
> } else {
> pr_warn("min_free_kbytes is not updated to %d because user defined value %d is preferred\n",
> - new_min_free_kbytes, user_min_free_kbytes);
> + new_min_free_kbytes, user_min_free_kbytes);
> }
> setup_per_zone_wmarks();
> refresh_zone_stat_thresholds();
> @@ -7013,7 +7013,7 @@ core_initcall(init_per_zone_wmark_min)
> * changes.
> */
> int min_free_kbytes_sysctl_handler(struct ctl_table *table, int write,
> - void __user *buffer, size_t *length, loff_t *ppos)
> + void __user *buffer, size_t *length, loff_t *ppos)
> {
> int rc;
>
> @@ -7029,7 +7029,7 @@ int min_free_kbytes_sysctl_handler(struct ctl_table *table, int write,
> }
>
> int watermark_scale_factor_sysctl_handler(struct ctl_table *table, int write,
> - void __user *buffer, size_t *length, loff_t *ppos)
> + void __user *buffer, size_t *length, loff_t *ppos)
> {
> int rc;
>
> @@ -7054,12 +7054,12 @@ static void setup_min_unmapped_ratio(void)
>
> for_each_zone(zone)
> zone->zone_pgdat->min_unmapped_pages += (zone->managed_pages *
> - sysctl_min_unmapped_ratio) / 100;
> + sysctl_min_unmapped_ratio) / 100;
> }
>
>
> int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *table, int write,
> - void __user *buffer, size_t *length, loff_t *ppos)
> + void __user *buffer, size_t *length, loff_t *ppos)
> {
> int rc;
>
> @@ -7082,11 +7082,11 @@ static void setup_min_slab_ratio(void)
>
> for_each_zone(zone)
> zone->zone_pgdat->min_slab_pages += (zone->managed_pages *
> - sysctl_min_slab_ratio) / 100;
> + sysctl_min_slab_ratio) / 100;
> }
>
> int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *table, int write,
> - void __user *buffer, size_t *length, loff_t *ppos)
> + void __user *buffer, size_t *length, loff_t *ppos)
> {
> int rc;
>
> @@ -7110,7 +7110,7 @@ int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *table, int write,
> * if in function of the boot time zone sizes.
> */
> int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *table, int write,
> - void __user *buffer, size_t *length, loff_t *ppos)
> + void __user *buffer, size_t *length, loff_t *ppos)
> {
> proc_dointvec_minmax(table, write, buffer, length, ppos);
> setup_per_zone_lowmem_reserve();
> @@ -7123,7 +7123,7 @@ int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *table, int write,
> * pagelist can have before it gets flushed back to buddy allocator.
> */
> int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *table, int write,
> - void __user *buffer, size_t *length, loff_t *ppos)
> + void __user *buffer, size_t *length, loff_t *ppos)
> {
> struct zone *zone;
> int old_percpu_pagelist_fraction;
> @@ -7153,7 +7153,7 @@ int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *table, int write,
>
> for_each_possible_cpu(cpu)
> pageset_set_high_and_batch(zone,
> - per_cpu_ptr(zone->pageset, cpu));
> + per_cpu_ptr(zone->pageset, cpu));
> }
> out:
> mutex_unlock(&pcp_batch_high_lock);
> @@ -7461,7 +7461,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc,
> }
>
> nr_reclaimed = reclaim_clean_pages_from_list(cc->zone,
> - &cc->migratepages);
> + &cc->migratepages);
> cc->nr_migratepages -= nr_reclaimed;
>
> ret = migrate_pages(&cc->migratepages, alloc_migrate_target,
> @@ -7645,7 +7645,7 @@ void __meminit zone_pcp_update(struct zone *zone)
> mutex_lock(&pcp_batch_high_lock);
> for_each_possible_cpu(cpu)
> pageset_set_high_and_batch(zone,
> - per_cpu_ptr(zone->pageset, cpu));
> + per_cpu_ptr(zone->pageset, cpu));
> mutex_unlock(&pcp_batch_high_lock);
> }
> #endif
> --
> 2.10.0.rc2.1.g053435c
>
> --
> To unsubscribe, send a message with 'unsubscribe linux-mm' in
> the body to majordomo@...ck.org. For more info on Linux MM,
> see: http://www.linux-mm.org/ .
> Don't email: <a href=mailto:"dont@...ck.org"> email@...ck.org </a>
--
Michal Hocko
SUSE Labs
Powered by blists - more mailing lists