[PATCH] xen/mm: page_alloc fix duplicated order shift operation in the loop

[Paran Lee <p4ranlee@xxxxxxxxx>]

It doesn't seem necessary to do that
duplicate calculation of order shift 2^@order in the loop.

In addition, I fixed type of total_avail_pages from long
to unsigned long. because when total_avail_pages static variable
substitute in functions of page alloc local variable,
type of local variables is unsigned long.

Signed-off-by: Paran Lee <p4ranlee@xxxxxxxxx>
---
 xen/common/page_alloc.c | 51 ++++++++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 24 deletions(-)

diff --git a/xen/common/page_alloc.c b/xen/common/page_alloc.c
index 319029140f..9a955ce84e 100644
--- a/xen/common/page_alloc.c
+++ b/xen/common/page_alloc.c
@@ -456,7 +456,7 @@ static heap_by_zone_and_order_t *_heap[MAX_NUMNODES];
 static unsigned long node_need_scrub[MAX_NUMNODES];
 
 static unsigned long *avail[MAX_NUMNODES];
-static long total_avail_pages;
+static unsigned long total_avail_pages;
 
 static DEFINE_SPINLOCK(heap_lock);
 static long outstanding_claims; /* total outstanding claims by all domains */
@@ -922,8 +922,9 @@ static struct page_info *alloc_heap_pages(
     struct domain *d)
 {
     nodeid_t node;
-    unsigned int i, buddy_order, zone, first_dirty;
-    unsigned long request = 1UL << order;
+    unsigned int buddy_order, zone, first_dirty;
+    unsigned int buddy_request;
+    unsigned long i, request = 1UL << order;
     struct page_info *pg;
     bool need_tlbflush = false;
     uint32_t tlbflush_timestamp = 0;
@@ -975,16 +976,17 @@ static struct page_info *alloc_heap_pages(
     while ( buddy_order != order )
     {
         buddy_order--;
+        buddy_request = 1U << buddy_order;
         page_list_add_scrub(pg, node, zone, buddy_order,
-                            (1U << buddy_order) > first_dirty ?
+                            buddy_request > first_dirty ?
                             first_dirty : INVALID_DIRTY_IDX);
-        pg += 1U << buddy_order;
+        pg += buddy_request;
 
         if ( first_dirty != INVALID_DIRTY_IDX )
         {
             /* Adjust first_dirty */
-            if ( first_dirty >= 1U << buddy_order )
-                first_dirty -= 1U << buddy_order;
+            if ( first_dirty >= buddy_request )
+                first_dirty -= buddy_request;
             else
                 first_dirty = 0; /* We've moved past original first_dirty */
         }
@@ -1000,13 +1002,13 @@ static struct page_info *alloc_heap_pages(
     if ( d != NULL )
         d->last_alloc_node = node;
 
-    for ( i = 0; i < (1 << order); i++ )
+    for ( i = 0; i < request; i++ )
     {
         /* Reference count must continuously be zero for free pages. */
         if ( (pg[i].count_info & ~PGC_need_scrub) != PGC_state_free )
         {
             printk(XENLOG_ERR
-                   "pg[%u] MFN %"PRI_mfn" c=%#lx o=%u v=%#lx t=%#x\n",
+                   "pg[%lu] MFN %"PRI_mfn" c=%#lx o=%u v=%#lx t=%#x\n",
                    i, mfn_x(page_to_mfn(pg + i)),
                    pg[i].count_info, pg[i].v.free.order,
                    pg[i].u.free.val, pg[i].tlbflush_timestamp);
@@ -1034,7 +1036,7 @@ static struct page_info *alloc_heap_pages(
     if ( first_dirty != INVALID_DIRTY_IDX ||
          (scrub_debug && !(memflags & MEMF_no_scrub)) )
     {
-        for ( i = 0; i < (1U << order); i++ )
+        for ( i = 0; i < request; i++ )
         {
             if ( test_and_clear_bit(_PGC_need_scrub, &pg[i].count_info) )
             {
@@ -1063,7 +1065,7 @@ static struct page_info *alloc_heap_pages(
      * can control its own visibility of/through the cache.
      */
     mfn = page_to_mfn(pg);
-    for ( i = 0; i < (1U << order); i++ )
+    for ( i = 0; i < request; i++ )
         flush_page_to_ram(mfn_x(mfn) + i, !(memflags & MEMF_no_icache_flush));
 
     return pg;
@@ -1437,15 +1439,16 @@ static void free_heap_pages(
 {
     unsigned long mask;
     mfn_t mfn = page_to_mfn(pg);
-    unsigned int i, node = phys_to_nid(mfn_to_maddr(mfn));
+    unsigned int node = phys_to_nid(mfn_to_maddr(mfn));
     unsigned int zone = page_to_zone(pg);
+    unsigned long i, request = 1UL << order;
     bool pg_offlined = false;
 
     ASSERT(order <= MAX_ORDER);
 
     spin_lock(&heap_lock);
 
-    for ( i = 0; i < (1 << order); i++ )
+    for ( i = 0; i < request; i++ )
     {
         if ( mark_page_free(&pg[i], mfn_add(mfn, i)) )
             pg_offlined = true;
@@ -1457,11 +1460,11 @@ static void free_heap_pages(
         }
     }
 
-    avail[node][zone] += 1 << order;
-    total_avail_pages += 1 << order;
+    avail[node][zone] += request;
+    total_avail_pages += request;
     if ( need_scrub )
     {
-        node_need_scrub[node] += 1 << order;
+        node_need_scrub[node] += request;
         pg->u.free.first_dirty = 0;
     }
     else
@@ -1490,7 +1493,7 @@ static void free_heap_pages(
             /* Update predecessor's first_dirty if necessary. */
             if ( predecessor->u.free.first_dirty == INVALID_DIRTY_IDX &&
                  pg->u.free.first_dirty != INVALID_DIRTY_IDX )
-                predecessor->u.free.first_dirty = (1U << order) +
+                predecessor->u.free.first_dirty = mask +
                                                   pg->u.free.first_dirty;
 
             pg = predecessor;
@@ -1511,7 +1514,7 @@ static void free_heap_pages(
             /* Update pg's first_dirty if necessary. */
             if ( pg->u.free.first_dirty == INVALID_DIRTY_IDX &&
                  successor->u.free.first_dirty != INVALID_DIRTY_IDX )
-                pg->u.free.first_dirty = (1U << order) +
+                pg->u.free.first_dirty = mask +
                                          successor->u.free.first_dirty;
 
             page_list_del(successor, &heap(node, zone, order));
@@ -2416,7 +2419,7 @@ struct page_info *alloc_domheap_pages(
 void free_domheap_pages(struct page_info *pg, unsigned int order)
 {
     struct domain *d = page_get_owner(pg);
-    unsigned int i;
+    unsigned long i, request = 1UL << order;
     bool drop_dom_ref;
 
     ASSERT(!in_irq());
@@ -2426,10 +2429,10 @@ void free_domheap_pages(struct page_info *pg, unsigned 
int order)
         /* NB. May recursively lock from relinquish_memory(). */
         spin_lock_recursive(&d->page_alloc_lock);
 
-        for ( i = 0; i < (1 << order); i++ )
+        for ( i = 0; i < request; i++ )
             arch_free_heap_page(d, &pg[i]);
 
-        d->xenheap_pages -= 1 << order;
+        d->xenheap_pages -= request;
         drop_dom_ref = (d->xenheap_pages == 0);
 
         spin_unlock_recursive(&d->page_alloc_lock);
@@ -2443,12 +2446,12 @@ void free_domheap_pages(struct page_info *pg, unsigned 
int order)
             /* NB. May recursively lock from relinquish_memory(). */
             spin_lock_recursive(&d->page_alloc_lock);
 
-            for ( i = 0; i < (1 << order); i++ )
+            for ( i = 0; i < request; i++ )
             {
                 if ( pg[i].u.inuse.type_info & PGT_count_mask )
                 {
                     printk(XENLOG_ERR
-                           "pg[%u] MFN %"PRI_mfn" c=%#lx o=%u v=%#lx t=%#x\n",
+                           "pg[%lu] MFN %"PRI_mfn" c=%#lx o=%u v=%#lx t=%#x\n",
                            i, mfn_x(page_to_mfn(pg + i)),
                            pg[i].count_info, pg[i].v.free.order,
                            pg[i].u.free.val, pg[i].tlbflush_timestamp);
@@ -2462,7 +2465,7 @@ void free_domheap_pages(struct page_info *pg, unsigned 
int order)
                 }
             }
 
-            drop_dom_ref = !domain_adjust_tot_pages(d, -(1 << order));
+            drop_dom_ref = !domain_adjust_tot_pages(d, -request);
 
             spin_unlock_recursive(&d->page_alloc_lock);
 
-- 
2.25.1