--- initial
+++ final
@@ -1,73 +1,73 @@
 void *__init alloc_large_system_hash(const char *tablename, unsigned long bucketsize, unsigned long numentries, int scale, int flags, unsigned int *_hash_shift, unsigned int *_hash_mask, unsigned long low_limit, unsigned long high_limit) {
   unsigned long long max = high_limit;
   unsigned long log2qty, size;
   void *table = NULL;
   gfp_t gfp_flags;
   /* allow the kernel cmdline to have a say */
   if (!numentries) {
     /* round applicable memory size up to nearest megabyte */
     numentries = nr_kernel_pages;
     numentries -= arch_reserved_kernel_pages();
     /* It isn't necessary when PAGE_SIZE >= 1MB */
     if (PAGE_SHIFT < 20) numentries = round_up(numentries, (1 << 20) / PAGE_SIZE);
 #if __BITS_PER_LONG > 32
     if (!high_limit) {
       unsigned long adapt;
       for (adapt = ADAPT_SCALE_NPAGES; adapt < numentries; adapt <<= ADAPT_SCALE_SHIFT)
         scale++;
     }
 #endif
     /* limit to 1 bucket per 2^scale bytes of low memory */
     if (scale > PAGE_SHIFT)
       numentries >>= (scale - PAGE_SHIFT);
     else
       numentries <<= (PAGE_SHIFT - scale);
     /* Make sure we've got at least a 0-order allocation.. */
     if (unlikely(flags & HASH_SMALL)) {
       /* Makes no sense without HASH_EARLY */
       WARN_ON(!(flags & HASH_EARLY));
       if (!(numentries >> *_hash_shift)) {
         numentries = 1UL << *_hash_shift;
         BUG_ON(!numentries);
       }
     } else if (unlikely((numentries * bucketsize) < PAGE_SIZE))
       numentries = PAGE_SIZE / bucketsize;
   }
   numentries = roundup_pow_of_two(numentries);
   /* limit allocation size to 1/16 total memory by default */
   if (max == 0) {
     max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
     do_div(max, bucketsize);
   }
   max = min(max, 0x80000000ULL);
   if (numentries < low_limit) numentries = low_limit;
   if (numentries > max) numentries = max;
   log2qty = ilog2(numentries);
   gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
   do {
     size = bucketsize << log2qty;
     if (flags & HASH_EARLY) {
       if (flags & HASH_ZERO)
-        table = memblock_virt_alloc_nopanic(size, 0);
+        table = memblock_alloc_nopanic(size, 0);
       else
-        table = memblock_virt_alloc_raw(size, 0);
+        table = memblock_alloc_raw(size, 0);
     } else if (hashdist) {
       table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
     } else {
       /*
        * If bucketsize is not a power-of-two, we may free
        * some pages at the end of hash table which
        * alloc_pages_exact() automatically does
        */
       if (get_order(size) < MAX_ORDER) {
         table = alloc_pages_exact(size, gfp_flags);
         kmemleak_alloc(table, size, 1, gfp_flags);
       }
     }
   } while (!table && size > PAGE_SIZE && --log2qty);
   if (!table) panic("Failed to allocate %s hash table\n", tablename);
   pr_info("%s hash table entries: %ld (order: %d, %lu bytes)\n", tablename, 1UL << log2qty, ilog2(size) - PAGE_SHIFT, size);
   if (_hash_shift) *_hash_shift = log2qty;
   if (_hash_mask) *_hash_mask = (1 << log2qty) - 1;
   return table;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc_raw
+                       memblock_alloc_raw
				(e1,e2)

@@
expression e1,e2;
@@

-                       memblock_virt_alloc_nopanic
+                       memblock_alloc_nopanic
				(e1,e2)