Re: [PATCH] mm: Refactor conversion of pages to bytes macro definitions

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Tue 20-06-17 18:14:28, Nikolay Borisov wrote:
> Currently there are a multiple files with the following code:
>  #define K(x) ((x) << (PAGE_SHIFT - 10))
>  ... some code..
>  #undef K
> 
> This is mainly used to print out some memory-related statistics, where X is
> given in pages and the macro just converts it to kilobytes. In the future
> there is going to be more macros since there are intention to introduce
> byte-based memory counters [1]. This could lead to proliferation of
> multiple duplicated definition of various macros used to convert a quantity
> from one unit to another. Let's try and consolidate such definition in the
> mm.h header since currently it's being included in all files which exhibit
> this pattern. Also let's rename it to something a bit more verbose.
> 
> This patch doesn't introduce any functional changes
> 
> [1] https://patchwork.kernel.org/patch/9395205/
> 
> Signed-off-by: Nikolay Borisov <nborisov@xxxxxxxx>
> ---
>  arch/tile/mm/pgtable.c      |  2 --
>  drivers/base/node.c         | 66 ++++++++++++++++++-------------------
>  include/linux/mm.h          |  2 ++
>  kernel/debug/kdb/kdb_main.c |  3 +-
>  mm/backing-dev.c            | 22 +++++--------
>  mm/memcontrol.c             | 17 +++++-----
>  mm/oom_kill.c               | 19 +++++------
>  mm/page_alloc.c             | 80 ++++++++++++++++++++++-----------------------
>  8 files changed, 100 insertions(+), 111 deletions(-)

Those macros are quite trivial and we do not really save much code while
this touches a lot of code potentially causing some conflicts. So do we
really need this? I am usually very keen on removing duplication but
this doesn't seem to be worth all the troubles IMHO.

> 
> diff --git a/arch/tile/mm/pgtable.c b/arch/tile/mm/pgtable.c
> index 492a7361e58e..f04af570c1c2 100644
> --- a/arch/tile/mm/pgtable.c
> +++ b/arch/tile/mm/pgtable.c
> @@ -34,8 +34,6 @@
>  #include <asm/tlbflush.h>
>  #include <asm/homecache.h>
>  
> -#define K(x) ((x) << (PAGE_SHIFT-10))
> -
>  /**
>   * shatter_huge_page() - ensure a given address is mapped by a small page.
>   *
> diff --git a/drivers/base/node.c b/drivers/base/node.c
> index 5548f9686016..b6f563a3a3a9 100644
> --- a/drivers/base/node.c
> +++ b/drivers/base/node.c
> @@ -50,7 +50,6 @@ static inline ssize_t node_read_cpulist(struct device *dev,
>  static DEVICE_ATTR(cpumap,  S_IRUGO, node_read_cpumask, NULL);
>  static DEVICE_ATTR(cpulist, S_IRUGO, node_read_cpulist, NULL);
>  
> -#define K(x) ((x) << (PAGE_SHIFT - 10))
>  static ssize_t node_read_meminfo(struct device *dev,
>  			struct device_attribute *attr, char *buf)
>  {
> @@ -72,19 +71,19 @@ static ssize_t node_read_meminfo(struct device *dev,
>  		       "Node %d Inactive(file): %8lu kB\n"
>  		       "Node %d Unevictable:    %8lu kB\n"
>  		       "Node %d Mlocked:        %8lu kB\n",
> -		       nid, K(i.totalram),
> -		       nid, K(i.freeram),
> -		       nid, K(i.totalram - i.freeram),
> -		       nid, K(node_page_state(pgdat, NR_ACTIVE_ANON) +
> +		       nid, PtoK(i.totalram),
> +		       nid, PtoK(i.freeram),
> +		       nid, PtoK(i.totalram - i.freeram),
> +		       nid, PtoK(node_page_state(pgdat, NR_ACTIVE_ANON) +
>  				node_page_state(pgdat, NR_ACTIVE_FILE)),
> -		       nid, K(node_page_state(pgdat, NR_INACTIVE_ANON) +
> +		       nid, PtoK(node_page_state(pgdat, NR_INACTIVE_ANON) +
>  				node_page_state(pgdat, NR_INACTIVE_FILE)),
> -		       nid, K(node_page_state(pgdat, NR_ACTIVE_ANON)),
> -		       nid, K(node_page_state(pgdat, NR_INACTIVE_ANON)),
> -		       nid, K(node_page_state(pgdat, NR_ACTIVE_FILE)),
> -		       nid, K(node_page_state(pgdat, NR_INACTIVE_FILE)),
> -		       nid, K(node_page_state(pgdat, NR_UNEVICTABLE)),
> -		       nid, K(sum_zone_node_page_state(nid, NR_MLOCK)));
> +		       nid, PtoK(node_page_state(pgdat, NR_ACTIVE_ANON)),
> +		       nid, PtoK(node_page_state(pgdat, NR_INACTIVE_ANON)),
> +		       nid, PtoK(node_page_state(pgdat, NR_ACTIVE_FILE)),
> +		       nid, PtoK(node_page_state(pgdat, NR_INACTIVE_FILE)),
> +		       nid, PtoK(node_page_state(pgdat, NR_UNEVICTABLE)),
> +		       nid, PtoK(sum_zone_node_page_state(nid, NR_MLOCK)));
>  
>  #ifdef CONFIG_HIGHMEM
>  	n += sprintf(buf + n,
> @@ -92,10 +91,10 @@ static ssize_t node_read_meminfo(struct device *dev,
>  		       "Node %d HighFree:       %8lu kB\n"
>  		       "Node %d LowTotal:       %8lu kB\n"
>  		       "Node %d LowFree:        %8lu kB\n",
> -		       nid, K(i.totalhigh),
> -		       nid, K(i.freehigh),
> -		       nid, K(i.totalram - i.totalhigh),
> -		       nid, K(i.freeram - i.freehigh));
> +		       nid, PtoK(i.totalhigh),
> +		       nid, PtoK(i.freehigh),
> +		       nid, PtoK(i.totalram - i.totalhigh),
> +		       nid, PtoK(i.freeram - i.freehigh));
>  #endif
>  	n += sprintf(buf + n,
>  		       "Node %d Dirty:          %8lu kB\n"
> @@ -118,36 +117,35 @@ static ssize_t node_read_meminfo(struct device *dev,
>  		       "Node %d ShmemPmdMapped: %8lu kB\n"
>  #endif
>  			,
> -		       nid, K(node_page_state(pgdat, NR_FILE_DIRTY)),
> -		       nid, K(node_page_state(pgdat, NR_WRITEBACK)),
> -		       nid, K(node_page_state(pgdat, NR_FILE_PAGES)),
> -		       nid, K(node_page_state(pgdat, NR_FILE_MAPPED)),
> -		       nid, K(node_page_state(pgdat, NR_ANON_MAPPED)),
> -		       nid, K(i.sharedram),
> +		       nid, PtoK(node_page_state(pgdat, NR_FILE_DIRTY)),
> +		       nid, PtoK(node_page_state(pgdat, NR_WRITEBACK)),
> +		       nid, PtoK(node_page_state(pgdat, NR_FILE_PAGES)),
> +		       nid, PtoK(node_page_state(pgdat, NR_FILE_MAPPED)),
> +		       nid, PtoK(node_page_state(pgdat, NR_ANON_MAPPED)),
> +		       nid, PtoK(i.sharedram),
>  		       nid, sum_zone_node_page_state(nid, NR_KERNEL_STACK_KB),
> -		       nid, K(sum_zone_node_page_state(nid, NR_PAGETABLE)),
> -		       nid, K(node_page_state(pgdat, NR_UNSTABLE_NFS)),
> -		       nid, K(sum_zone_node_page_state(nid, NR_BOUNCE)),
> -		       nid, K(node_page_state(pgdat, NR_WRITEBACK_TEMP)),
> -		       nid, K(sum_zone_node_page_state(nid, NR_SLAB_RECLAIMABLE) +
> +		       nid, PtoK(sum_zone_node_page_state(nid, NR_PAGETABLE)),
> +		       nid, PtoK(node_page_state(pgdat, NR_UNSTABLE_NFS)),
> +		       nid, PtoK(sum_zone_node_page_state(nid, NR_BOUNCE)),
> +		       nid, PtoK(node_page_state(pgdat, NR_WRITEBACK_TEMP)),
> +		       nid, PtoK(sum_zone_node_page_state(nid, NR_SLAB_RECLAIMABLE) +
>  				sum_zone_node_page_state(nid, NR_SLAB_UNRECLAIMABLE)),
> -		       nid, K(sum_zone_node_page_state(nid, NR_SLAB_RECLAIMABLE)),
> +		       nid, PtoK(sum_zone_node_page_state(nid, NR_SLAB_RECLAIMABLE)),
>  #ifdef CONFIG_TRANSPARENT_HUGEPAGE
> -		       nid, K(sum_zone_node_page_state(nid, NR_SLAB_UNRECLAIMABLE)),
> -		       nid, K(node_page_state(pgdat, NR_ANON_THPS) *
> +		       nid, PtoK(sum_zone_node_page_state(nid, NR_SLAB_UNRECLAIMABLE)),
> +		       nid, PtoK(node_page_state(pgdat, NR_ANON_THPS) *
>  				       HPAGE_PMD_NR),
> -		       nid, K(node_page_state(pgdat, NR_SHMEM_THPS) *
> +		       nid, PtoK(node_page_state(pgdat, NR_SHMEM_THPS) *
>  				       HPAGE_PMD_NR),
> -		       nid, K(node_page_state(pgdat, NR_SHMEM_PMDMAPPED) *
> +		       nid, PtoK(node_page_state(pgdat, NR_SHMEM_PMDMAPPED) *
>  				       HPAGE_PMD_NR));
>  #else
> -		       nid, K(sum_zone_node_page_state(nid, NR_SLAB_UNRECLAIMABLE)));
> +		       nid, PtoK(sum_zone_node_page_state(nid, NR_SLAB_UNRECLAIMABLE)));
>  #endif
>  	n += hugetlb_report_node_meminfo(nid, buf + n);
>  	return n;
>  }
>  
> -#undef K
>  static DEVICE_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL);
>  
>  static ssize_t node_read_numastat(struct device *dev,
> diff --git a/include/linux/mm.h b/include/linux/mm.h
> index 6f543a47fc92..d8d80e2e9194 100644
> --- a/include/linux/mm.h
> +++ b/include/linux/mm.h
> @@ -93,6 +93,8 @@ extern int mmap_rnd_compat_bits __read_mostly;
>  #define mm_forbids_zeropage(X)	(0)
>  #endif
>  
> +#define PtoK(pages) ((pages) << (PAGE_SHIFT-10))
> +
>  /*
>   * Default maximum number of active map areas, this limits the number of vmas
>   * per mm struct. Users can overwrite this number by sysctl but there is a
> diff --git a/kernel/debug/kdb/kdb_main.c b/kernel/debug/kdb/kdb_main.c
> index c8146d53ca67..e833cb02d2c8 100644
> --- a/kernel/debug/kdb/kdb_main.c
> +++ b/kernel/debug/kdb/kdb_main.c
> @@ -2582,10 +2582,9 @@ static int kdb_summary(int argc, const char **argv)
>  #undef LOAD_INT
>  #undef LOAD_FRAC
>  	/* Display in kilobytes */
> -#define K(x) ((x) << (PAGE_SHIFT - 10))
>  	kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
>  		   "Buffers:        %8lu kB\n",
> -		   K(val.totalram), K(val.freeram), K(val.bufferram));
> +		   PtoK(val.totalram), PtoK(val.freeram), PtoK(val.bufferram));
>  	return 0;
>  }
>  
> diff --git a/mm/backing-dev.c b/mm/backing-dev.c
> index f028a9a472fd..0c09dd103109 100644
> --- a/mm/backing-dev.c
> +++ b/mm/backing-dev.c
> @@ -67,7 +67,6 @@ static int bdi_debug_stats_show(struct seq_file *m, void *v)
>  	global_dirty_limits(&background_thresh, &dirty_thresh);
>  	wb_thresh = wb_calc_thresh(wb, dirty_thresh);
>  
> -#define K(x) ((x) << (PAGE_SHIFT - 10))
>  	seq_printf(m,
>  		   "BdiWriteback:       %10lu kB\n"
>  		   "BdiReclaimable:     %10lu kB\n"
> @@ -83,20 +82,19 @@ static int bdi_debug_stats_show(struct seq_file *m, void *v)
>  		   "b_dirty_time:       %10lu\n"
>  		   "bdi_list:           %10u\n"
>  		   "state:              %10lx\n",
> -		   (unsigned long) K(wb_stat(wb, WB_WRITEBACK)),
> -		   (unsigned long) K(wb_stat(wb, WB_RECLAIMABLE)),
> -		   K(wb_thresh),
> -		   K(dirty_thresh),
> -		   K(background_thresh),
> -		   (unsigned long) K(wb_stat(wb, WB_DIRTIED)),
> -		   (unsigned long) K(wb_stat(wb, WB_WRITTEN)),
> -		   (unsigned long) K(wb->write_bandwidth),
> +		   (unsigned long) PtoK(wb_stat(wb, WB_WRITEBACK)),
> +		   (unsigned long) PtoK(wb_stat(wb, WB_RECLAIMABLE)),
> +		   PtoK(wb_thresh),
> +		   PtoK(dirty_thresh),
> +		   PtoK(background_thresh),
> +		   (unsigned long) PtoK(wb_stat(wb, WB_DIRTIED)),
> +		   (unsigned long) PtoK(wb_stat(wb, WB_WRITTEN)),
> +		   (unsigned long) PtoK(wb->write_bandwidth),
>  		   nr_dirty,
>  		   nr_io,
>  		   nr_more_io,
>  		   nr_dirty_time,
>  		   !list_empty(&bdi->bdi_list), bdi->wb.state);
> -#undef K
>  
>  	return 0;
>  }
> @@ -155,8 +153,6 @@ static ssize_t read_ahead_kb_store(struct device *dev,
>  	return count;
>  }
>  
> -#define K(pages) ((pages) << (PAGE_SHIFT - 10))
> -
>  #define BDI_SHOW(name, expr)						\
>  static ssize_t name##_show(struct device *dev,				\
>  			   struct device_attribute *attr, char *page)	\
> @@ -167,7 +163,7 @@ static ssize_t name##_show(struct device *dev,				\
>  }									\
>  static DEVICE_ATTR_RW(name);
>  
> -BDI_SHOW(read_ahead_kb, K(bdi->ra_pages))
> +BDI_SHOW(read_ahead_kb, PtoK(bdi->ra_pages))
>  
>  static ssize_t min_ratio_store(struct device *dev,
>  		struct device_attribute *attr, const char *buf, size_t count)
> diff --git a/mm/memcontrol.c b/mm/memcontrol.c
> index 94172089f52f..f0f1f4dbe816 100644
> --- a/mm/memcontrol.c
> +++ b/mm/memcontrol.c
> @@ -1132,7 +1132,6 @@ static const char *const memcg1_stat_names[] = {
>  	"swap",
>  };
>  
> -#define K(x) ((x) << (PAGE_SHIFT-10))
>  /**
>   * mem_cgroup_print_oom_info: Print OOM information relevant to memory controller.
>   * @memcg: The memory cgroup that went over limit
> @@ -1162,14 +1161,14 @@ void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
>  	rcu_read_unlock();
>  
>  	pr_info("memory: usage %llukB, limit %llukB, failcnt %lu\n",
> -		K((u64)page_counter_read(&memcg->memory)),
> -		K((u64)memcg->memory.limit), memcg->memory.failcnt);
> +		PtoK((u64)page_counter_read(&memcg->memory)),
> +		PtoK((u64)memcg->memory.limit), memcg->memory.failcnt);
>  	pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %lu\n",
> -		K((u64)page_counter_read(&memcg->memsw)),
> -		K((u64)memcg->memsw.limit), memcg->memsw.failcnt);
> +		PtoK((u64)page_counter_read(&memcg->memsw)),
> +		PtoK((u64)memcg->memsw.limit), memcg->memsw.failcnt);
>  	pr_info("kmem: usage %llukB, limit %llukB, failcnt %lu\n",
> -		K((u64)page_counter_read(&memcg->kmem)),
> -		K((u64)memcg->kmem.limit), memcg->kmem.failcnt);
> +		PtoK((u64)page_counter_read(&memcg->kmem)),
> +		PtoK((u64)memcg->kmem.limit), memcg->kmem.failcnt);
>  
>  	for_each_mem_cgroup_tree(iter, memcg) {
>  		pr_info("Memory cgroup stats for ");
> @@ -1180,12 +1179,12 @@ void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
>  			if (memcg1_stats[i] == MEMCG_SWAP && !do_swap_account)
>  				continue;
>  			pr_cont(" %s:%luKB", memcg1_stat_names[i],
> -				K(memcg_page_state(iter, memcg1_stats[i])));
> +				PtoK(memcg_page_state(iter, memcg1_stats[i])));
>  		}
>  
>  		for (i = 0; i < NR_LRU_LISTS; i++)
>  			pr_cont(" %s:%luKB", mem_cgroup_lru_names[i],
> -				K(mem_cgroup_nr_lru_pages(iter, BIT(i))));
> +				PtoK(mem_cgroup_nr_lru_pages(iter, BIT(i))));
>  
>  		pr_cont("\n");
>  	}
> diff --git a/mm/oom_kill.c b/mm/oom_kill.c
> index 04c9143a8625..d83801347c96 100644
> --- a/mm/oom_kill.c
> +++ b/mm/oom_kill.c
> @@ -1,6 +1,6 @@
>  /*
>   *  linux/mm/oom_kill.c
> - * 
> + *
>   *  Copyright (C)  1998,2000  Rik van Riel
>   *	Thanks go out to Claus Fischer for some serious inspiration and
>   *	for goading me into coding this file...
> @@ -435,8 +435,6 @@ static DECLARE_WAIT_QUEUE_HEAD(oom_victims_wait);
>  
>  static bool oom_killer_disabled __read_mostly;
>  
> -#define K(x) ((x) << (PAGE_SHIFT-10))
> -
>  /*
>   * task->mm can be NULL if the task is the exited group leader.  So to
>   * determine whether the task is using a particular mm, we examine all the
> @@ -533,9 +531,9 @@ static bool __oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm)
>  	tlb_finish_mmu(&tlb, 0, -1);
>  	pr_info("oom_reaper: reaped process %d (%s), now anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
>  			task_pid_nr(tsk), tsk->comm,
> -			K(get_mm_counter(mm, MM_ANONPAGES)),
> -			K(get_mm_counter(mm, MM_FILEPAGES)),
> -			K(get_mm_counter(mm, MM_SHMEMPAGES)));
> +			PtoK(get_mm_counter(mm, MM_ANONPAGES)),
> +			PtoK(get_mm_counter(mm, MM_FILEPAGES)),
> +			PtoK(get_mm_counter(mm, MM_SHMEMPAGES)));
>  	up_read(&mm->mmap_sem);
>  
>  	/*
> @@ -884,10 +882,10 @@ static void oom_kill_process(struct oom_control *oc, const char *message)
>  	do_send_sig_info(SIGKILL, SEND_SIG_FORCED, victim, true);
>  	mark_oom_victim(victim);
>  	pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
> -		task_pid_nr(victim), victim->comm, K(victim->mm->total_vm),
> -		K(get_mm_counter(victim->mm, MM_ANONPAGES)),
> -		K(get_mm_counter(victim->mm, MM_FILEPAGES)),
> -		K(get_mm_counter(victim->mm, MM_SHMEMPAGES)));
> +		task_pid_nr(victim), victim->comm, PtoK(victim->mm->total_vm),
> +		PtoK(get_mm_counter(victim->mm, MM_ANONPAGES)),
> +		PtoK(get_mm_counter(victim->mm, MM_FILEPAGES)),
> +		PtoK(get_mm_counter(victim->mm, MM_SHMEMPAGES)));
>  	task_unlock(victim);
>  
>  	/*
> @@ -929,7 +927,6 @@ static void oom_kill_process(struct oom_control *oc, const char *message)
>  	mmdrop(mm);
>  	put_task_struct(victim);
>  }
> -#undef K
>  
>  /*
>   * Determines whether the kernel must panic because of the panic_on_oom sysctl.
> diff --git a/mm/page_alloc.c b/mm/page_alloc.c
> index 2302f250d6b1..5785a2f8d7db 100644
> --- a/mm/page_alloc.c
> +++ b/mm/page_alloc.c
> @@ -4460,8 +4460,6 @@ static bool show_mem_node_skip(unsigned int flags, int nid, nodemask_t *nodemask
>  	return !node_isset(nid, *nodemask);
>  }
>  
> -#define K(x) ((x) << (PAGE_SHIFT-10))
> -
>  static void show_migration_types(unsigned char type)
>  {
>  	static const char types[MIGRATE_TYPES] = {
> @@ -4565,25 +4563,27 @@ void show_free_areas(unsigned int filter, nodemask_t *nodemask)
>  			" all_unreclaimable? %s"
>  			"\n",
>  			pgdat->node_id,
> -			K(node_page_state(pgdat, NR_ACTIVE_ANON)),
> -			K(node_page_state(pgdat, NR_INACTIVE_ANON)),
> -			K(node_page_state(pgdat, NR_ACTIVE_FILE)),
> -			K(node_page_state(pgdat, NR_INACTIVE_FILE)),
> -			K(node_page_state(pgdat, NR_UNEVICTABLE)),
> -			K(node_page_state(pgdat, NR_ISOLATED_ANON)),
> -			K(node_page_state(pgdat, NR_ISOLATED_FILE)),
> -			K(node_page_state(pgdat, NR_FILE_MAPPED)),
> -			K(node_page_state(pgdat, NR_FILE_DIRTY)),
> -			K(node_page_state(pgdat, NR_WRITEBACK)),
> -			K(node_page_state(pgdat, NR_SHMEM)),
> +			PtoK(node_page_state(pgdat, NR_ACTIVE_ANON)),
> +			PtoK(node_page_state(pgdat, NR_INACTIVE_ANON)),
> +			PtoK(node_page_state(pgdat, NR_ACTIVE_FILE)),
> +			PtoK(node_page_state(pgdat, NR_INACTIVE_FILE)),
> +			PtoK(node_page_state(pgdat, NR_UNEVICTABLE)),
> +			PtoK(node_page_state(pgdat, NR_ISOLATED_ANON)),
> +			PtoK(node_page_state(pgdat, NR_ISOLATED_FILE)),
> +			PtoK(node_page_state(pgdat, NR_FILE_MAPPED)),
> +			PtoK(node_page_state(pgdat, NR_FILE_DIRTY)),
> +			PtoK(node_page_state(pgdat, NR_WRITEBACK)),
> +			PtoK(node_page_state(pgdat, NR_SHMEM)),
>  #ifdef CONFIG_TRANSPARENT_HUGEPAGE
> -			K(node_page_state(pgdat, NR_SHMEM_THPS) * HPAGE_PMD_NR),
> -			K(node_page_state(pgdat, NR_SHMEM_PMDMAPPED)
> +			PtoK(node_page_state(pgdat, NR_SHMEM_THPS) *
> +			     HPAGE_PMD_NR),
> +			PtoK(node_page_state(pgdat, NR_SHMEM_PMDMAPPED)
>  					* HPAGE_PMD_NR),
> -			K(node_page_state(pgdat, NR_ANON_THPS) * HPAGE_PMD_NR),
> +			PtoK(node_page_state(pgdat, NR_ANON_THPS) *
> +			     HPAGE_PMD_NR),
>  #endif
> -			K(node_page_state(pgdat, NR_WRITEBACK_TEMP)),
> -			K(node_page_state(pgdat, NR_UNSTABLE_NFS)),
> +			PtoK(node_page_state(pgdat, NR_WRITEBACK_TEMP)),
> +			PtoK(node_page_state(pgdat, NR_UNSTABLE_NFS)),
>  			pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES ?
>  				"yes" : "no");
>  	}
> @@ -4624,27 +4624,27 @@ void show_free_areas(unsigned int filter, nodemask_t *nodemask)
>  			" free_cma:%lukB"
>  			"\n",
>  			zone->name,
> -			K(zone_page_state(zone, NR_FREE_PAGES)),
> -			K(min_wmark_pages(zone)),
> -			K(low_wmark_pages(zone)),
> -			K(high_wmark_pages(zone)),
> -			K(zone_page_state(zone, NR_ZONE_ACTIVE_ANON)),
> -			K(zone_page_state(zone, NR_ZONE_INACTIVE_ANON)),
> -			K(zone_page_state(zone, NR_ZONE_ACTIVE_FILE)),
> -			K(zone_page_state(zone, NR_ZONE_INACTIVE_FILE)),
> -			K(zone_page_state(zone, NR_ZONE_UNEVICTABLE)),
> -			K(zone_page_state(zone, NR_ZONE_WRITE_PENDING)),
> -			K(zone->present_pages),
> -			K(zone->managed_pages),
> -			K(zone_page_state(zone, NR_MLOCK)),
> -			K(zone_page_state(zone, NR_SLAB_RECLAIMABLE)),
> -			K(zone_page_state(zone, NR_SLAB_UNRECLAIMABLE)),
> +			PtoK(zone_page_state(zone, NR_FREE_PAGES)),
> +			PtoK(min_wmark_pages(zone)),
> +			PtoK(low_wmark_pages(zone)),
> +			PtoK(high_wmark_pages(zone)),
> +			PtoK(zone_page_state(zone, NR_ZONE_ACTIVE_ANON)),
> +			PtoK(zone_page_state(zone, NR_ZONE_INACTIVE_ANON)),
> +			PtoK(zone_page_state(zone, NR_ZONE_ACTIVE_FILE)),
> +			PtoK(zone_page_state(zone, NR_ZONE_INACTIVE_FILE)),
> +			PtoK(zone_page_state(zone, NR_ZONE_UNEVICTABLE)),
> +			PtoK(zone_page_state(zone, NR_ZONE_WRITE_PENDING)),
> +			PtoK(zone->present_pages),
> +			PtoK(zone->managed_pages),
> +			PtoK(zone_page_state(zone, NR_MLOCK)),
> +			PtoK(zone_page_state(zone, NR_SLAB_RECLAIMABLE)),
> +			PtoK(zone_page_state(zone, NR_SLAB_UNRECLAIMABLE)),
>  			zone_page_state(zone, NR_KERNEL_STACK_KB),
> -			K(zone_page_state(zone, NR_PAGETABLE)),
> -			K(zone_page_state(zone, NR_BOUNCE)),
> -			K(free_pcp),
> -			K(this_cpu_read(zone->pageset->pcp.count)),
> -			K(zone_page_state(zone, NR_FREE_CMA_PAGES)));
> +			PtoK(zone_page_state(zone, NR_PAGETABLE)),
> +			PtoK(zone_page_state(zone, NR_BOUNCE)),
> +			PtoK(free_pcp),
> +			PtoK(this_cpu_read(zone->pageset->pcp.count)),
> +			PtoK(zone_page_state(zone, NR_FREE_CMA_PAGES)));
>  		printk("lowmem_reserve[]:");
>  		for (i = 0; i < MAX_NR_ZONES; i++)
>  			printk(KERN_CONT " %ld", zone->lowmem_reserve[i]);
> @@ -4678,11 +4678,11 @@ void show_free_areas(unsigned int filter, nodemask_t *nodemask)
>  		spin_unlock_irqrestore(&zone->lock, flags);
>  		for (order = 0; order < MAX_ORDER; order++) {
>  			printk(KERN_CONT "%lu*%lukB ",
> -			       nr[order], K(1UL) << order);
> +			       nr[order], PtoK(1UL) << order);
>  			if (nr[order])
>  				show_migration_types(types[order]);
>  		}
> -		printk(KERN_CONT "= %lukB\n", K(total));
> +		printk(KERN_CONT "= %lukB\n", PtoK(total));
>  	}
>  
>  	hugetlb_show_meminfo();
> -- 
> 2.7.4

-- 
Michal Hocko
SUSE Labs
--
To unsubscribe from this list: send the line "unsubscribe cgroups" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html



[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux OMAP]     [Linux MIPS]     [eCos]     [Asterisk Internet PBX]     [Linux API]     [Monitors]

  Powered by Linux