x86: mtrr_cleanup prepare to make gran_size to less 1M

make the print out right with size < 1M

Signed-off-by: Yinghai Lu <yhlu.kernel@gmail.com>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>

diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c
index ae0ca97e20bda3775a8a3f271e54ceecfb80f641..b1bd1038c913db8e9c43e991105e0c502581df72 100644 (file)
--- a/arch/x86/kernel/cpu/mtrr/main.c
+++ b/arch/x86/kernel/cpu/mtrr/main.c
@@ -905,6 +905,27 @@ set_var_mtrr_all(unsigned int address_bits)
        }
 }
 
+static unsigned long to_size_factor(unsigned long sizek, char *factorp)
+{
+       char factor;
+       unsigned long base = sizek;
+
+       if (base & ((1<<10) - 1)) {
+               /* not MB alignment */
+               factor = 'K';
+       } else if (base & ((1<<20) - 1)){
+               factor = 'M';
+               base >>= 10;
+       } else {
+               factor = 'G';
+               base >>= 20;
+       }
+
+       *factorp = factor;
+
+       return base;
+}
+
 static unsigned int __init
 range_to_mtrr(unsigned int reg, unsigned long range_startk,
              unsigned long range_sizek, unsigned char type)
@@ -926,13 +947,21 @@ range_to_mtrr(unsigned int reg, unsigned long range_startk,
                        align = max_align;
 
                sizek = 1 << align;
-               if (debug_print)
+               if (debug_print) {
+                       char start_factor = 'K', size_factor = 'K';
+                       unsigned long start_base, size_base;
+
+                       start_base = to_size_factor(range_startk, &start_factor),
+                       size_base = to_size_factor(sizek, &size_factor),
+
                        printk(KERN_DEBUG "Setting variable MTRR %d, "
-                               "base: %ldMB, range: %ldMB, type %s\n",
-                               reg, range_startk >> 10, sizek >> 10,
+                               "base: %ld%cB, range: %ld%cB, type %s\n",
+                               reg, start_base, start_factor,
+                               size_base, size_factor,
                                (type == MTRR_TYPE_UNCACHABLE)?"UC":
                                    ((type == MTRR_TYPE_WRBACK)?"WB":"Other")
                                );
+               }
                save_var_mtrr(reg++, range_startk, sizek, type);
                range_startk += sizek;
                range_sizek -= sizek;
@@ -1245,6 +1274,8 @@ static int __init mtrr_cleanup(unsigned address_bits)
 
        if (mtrr_chunk_size && mtrr_gran_size) {
                int num_reg;
+               char gran_factor, chunk_factor, lose_factor;
+               unsigned long gran_base, chunk_base, lose_base;
 
                debug_print++;
                /* convert ranges to var ranges state */
@@ -1270,12 +1301,15 @@ static int __init mtrr_cleanup(unsigned address_bits)
                        result[i].lose_cover_sizek =
                                (range_sums - range_sums_new) << PSHIFT;
 
-               printk(KERN_INFO "%sgran_size: %ldM \tchunk_size: %ldM \t",
-                        result[i].bad?"*BAD*":" ", result[i].gran_sizek >> 10,
-                        result[i].chunk_sizek >> 10);
-               printk(KERN_CONT "num_reg: %d  \tlose cover RAM: %s%ldM \n",
+               gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
+               chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
+               lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
+               printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t",
+                        result[i].bad?"*BAD*":" ",
+                        gran_base, gran_factor, chunk_base, chunk_factor);
+               printk(KERN_CONT "num_reg: %d  \tlose cover RAM: %s%ld%c\n",
                         result[i].num_reg, result[i].bad?"-":"",
-                        result[i].lose_cover_sizek >> 10);
+                        lose_base, lose_factor);
                if (!result[i].bad) {
                        set_var_mtrr_all(address_bits);
                        return 1;
@@ -1290,14 +1324,25 @@ static int __init mtrr_cleanup(unsigned address_bits)
        memset(min_loss_pfn, 0xff, sizeof(min_loss_pfn));
        memset(result, 0, sizeof(result));
        for (gran_size = (1ULL<<20); gran_size < (1ULL<<32); gran_size <<= 1) {
+               char gran_factor;
+               unsigned long gran_base;
+
+               if (debug_print)
+                       gran_base = to_size_factor(gran_size >> 10, &gran_factor);
+
                for (chunk_size = gran_size; chunk_size < (1ULL<<32);
                     chunk_size <<= 1) {
                        int num_reg;
 
-                       if (debug_print)
-                               printk(KERN_INFO
-                              "\ngran_size: %lldM   chunk_size_size: %lldM\n",
-                                      gran_size >> 20, chunk_size >> 20);
+                       if (debug_print) {
+                               char chunk_factor;
+                               unsigned long chunk_base;
+
+                               chunk_base = to_size_factor(chunk_size>>10, &chunk_factor),
+                               printk(KERN_INFO "\n");
+                               printk(KERN_INFO "gran_size: %ld%c   chunk_size: %ld%c \n",
+                                      gran_base, gran_factor, chunk_base, chunk_factor);
+                       }
                        if (i >= NUM_RESULT)
                                continue;
 
@@ -1340,12 +1385,18 @@ static int __init mtrr_cleanup(unsigned address_bits)
 
        /* print out all */
        for (i = 0; i < NUM_RESULT; i++) {
-               printk(KERN_INFO "%sgran_size: %ldM \tchunk_size: %ldM \t",
-                      result[i].bad?"*BAD* ":" ", result[i].gran_sizek >> 10,
-                      result[i].chunk_sizek >> 10);
-               printk(KERN_CONT "num_reg: %d \tlose RAM: %s%ldM\n",
-                      result[i].num_reg, result[i].bad?"-":"",
-                      result[i].lose_cover_sizek >> 10);
+               char gran_factor, chunk_factor, lose_factor;
+               unsigned long gran_base, chunk_base, lose_base;
+
+               gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
+               chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
+               lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
+               printk(KERN_INFO "%sgran_size: %ld%c \tchunk_size: %ld%c \t",
+                        result[i].bad?"*BAD*":" ",
+                        gran_base, gran_factor, chunk_base, chunk_factor);
+               printk(KERN_CONT "num_reg: %d  \tlose cover RAM: %s%ld%c\n",
+                        result[i].num_reg, result[i].bad?"-":"",
+                        lose_base, lose_factor);
        }
 
        /* try to find the optimal index */
@@ -1370,14 +1421,18 @@ static int __init mtrr_cleanup(unsigned address_bits)
        }
 
        if (index_good != -1) {
+               char gran_factor, chunk_factor, lose_factor;
+               unsigned long gran_base, chunk_base, lose_base;
+
                printk(KERN_INFO "Found optimal setting for mtrr clean up\n");
                i = index_good;
-               printk(KERN_INFO "gran_size: %ldM \tchunk_size: %ldM \t",
-                               result[i].gran_sizek >> 10,
-                               result[i].chunk_sizek >> 10);
-               printk(KERN_CONT "num_reg: %d \tlose RAM: %ldM\n",
-                               result[i].num_reg,
-                               result[i].lose_cover_sizek >> 10);
+               gran_base = to_size_factor(result[i].gran_sizek, &gran_factor),
+               chunk_base = to_size_factor(result[i].chunk_sizek, &chunk_factor),
+               lose_base = to_size_factor(result[i].lose_cover_sizek, &lose_factor),
+               printk(KERN_INFO "gran_size: %ld%c \tchunk_size: %ld%c \t",
+                        gran_base, gran_factor, chunk_base, chunk_factor);
+               printk(KERN_CONT "num_reg: %d  \tlose RAM: %ld%c\n",
+                        result[i].num_reg, lose_base, lose_factor);
                /* convert ranges to var ranges state */
                chunk_size = result[i].chunk_sizek;
                chunk_size <<= 10;