for_each_online_node(nid) {
                bootmem_data_t *bdata = &bootmem_node_data[nid];
-               unsigned long start_pfn = bdata->node_boot_start >> PAGE_SHIFT;
+               unsigned long start_pfn = bdata->node_min_pfn;
                unsigned long end_pfn = bdata->node_low_pfn;
 
                if (dma_local_pfn >= end_pfn - start_pfn)
 
                return;
 
        bdata = NODE_DATA(0)->bdata;
-       sdram_start = bdata->node_boot_start;
+       sdram_start = bdata->node_min_pfn << PAGE_SHIFT;
        sdram_size = (bdata->node_low_pfn << PAGE_SHIFT) - sdram_start;
        reserved = 0;
        for (i = 0; ; i++) {
 
 
 #endif
-
-
 
                unsigned long zones_size[MAX_NR_ZONES];
                unsigned long low, start_pfn;
 
-               start_pfn = pgdat->bdata->node_boot_start;
-               start_pfn >>= PAGE_SHIFT;
+               start_pfn = pgdat->bdata->node_min_pfn;
                low = pgdat->bdata->node_low_pfn;
 
                memset(zones_size, 0, sizeof(zones_size));
 
 static int __init build_node_maps(unsigned long start, unsigned long len,
                                  int node)
 {
-       unsigned long cstart, epfn, end = start + len;
+       unsigned long spfn, epfn, end = start + len;
        struct bootmem_data *bdp = &bootmem_node_data[node];
 
        epfn = GRANULEROUNDUP(end) >> PAGE_SHIFT;
-       cstart = GRANULEROUNDDOWN(start);
+       spfn = GRANULEROUNDDOWN(start) >> PAGE_SHIFT;
 
        if (!bdp->node_low_pfn) {
-               bdp->node_boot_start = cstart;
+               bdp->node_min_pfn = spfn;
                bdp->node_low_pfn = epfn;
        } else {
-               bdp->node_boot_start = min(cstart, bdp->node_boot_start);
+               bdp->node_min_pfn = min(spfn, bdp->node_min_pfn);
                bdp->node_low_pfn = max(epfn, bdp->node_low_pfn);
        }
 
 static int __init find_pernode_space(unsigned long start, unsigned long len,
                                     int node)
 {
-       unsigned long epfn;
+       unsigned long spfn, epfn;
        unsigned long pernodesize = 0, pernode, pages, mapsize;
        struct bootmem_data *bdp = &bootmem_node_data[node];
 
+       spfn = start >> PAGE_SHIFT;
        epfn = (start + len) >> PAGE_SHIFT;
 
-       pages = bdp->node_low_pfn - (bdp->node_boot_start >> PAGE_SHIFT);
+       pages = bdp->node_low_pfn - bdp->node_min_pfn;
        mapsize = bootmem_bootmap_pages(pages) << PAGE_SHIFT;
 
        /*
         * Make sure this memory falls within this node's usable memory
         * since we may have thrown some away in build_maps().
         */
-       if (start < bdp->node_boot_start || epfn > bdp->node_low_pfn)
+       if (spfn < bdp->node_min_pfn || epfn > bdp->node_low_pfn)
                return 0;
 
        /* Don't setup this node's local space twice... */
                bdp = pdp->bdata;
 
                /* First the bootmem_map itself */
-               pages = bdp->node_low_pfn - (bdp->node_boot_start>>PAGE_SHIFT);
+               pages = bdp->node_low_pfn - bdp->node_min_pfn;
                size = bootmem_bootmap_pages(pages) << PAGE_SHIFT;
                base = __pa(bdp->node_bootmem_map);
                reserve_bootmem_node(pdp, base, size, BOOTMEM_DEFAULT);
 
                init_bootmem_node(pgdat_list[node],
                                  map>>PAGE_SHIFT,
-                                 bdp->node_boot_start>>PAGE_SHIFT,
+                                 bdp->node_min_pfn,
                                  bdp->node_low_pfn);
        }
 
 
        return max_low_pfn;
 }
 
-#define START_PFN(nid) \
-       (NODE_DATA(nid)->bdata->node_boot_start >> PAGE_SHIFT)
+#define START_PFN(nid)         (NODE_DATA(nid)->bdata->node_min_pfn)
 #define MAX_LOW_PFN(nid)       (NODE_DATA(nid)->bdata->node_low_pfn)
 
 unsigned long __init zone_sizes_init(void)
 
 #endif
 
 /* It'd be good if these lines were in the standard header file. */
-#define START_PFN(nid) \
-       (NODE_DATA(nid)->bdata->node_boot_start >> PAGE_SHIFT)
+#define START_PFN(nid)         (NODE_DATA(nid)->bdata->node_min_pfn)
 #define MAX_LOW_PFN(nid)       (NODE_DATA(nid)->bdata->node_low_pfn)
 
 #ifndef CONFIG_DISCONTIGMEM
        printk (KERN_INFO "Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
 }
 #endif
-
 
 
        /* declare the sizes of the RAM zones (only use the normal zone) */
        zones_size[ZONE_NORMAL] =
-               (contig_page_data.bdata->node_low_pfn) -
-               (contig_page_data.bdata->node_boot_start >> PAGE_SHIFT);
+               contig_page_data.bdata->node_low_pfn -
+               contig_page_data.bdata->node_min_pfn;
 
        /* pass the memory from the bootmem allocator to the main allocator */
        free_area_init(zones_size);
        if (!mem_map)
                BUG();
 
-#define START_PFN      (contig_page_data.bdata->node_boot_start >> PAGE_SHIFT)
+#define START_PFN      (contig_page_data.bdata->node_min_pfn)
 #define MAX_LOW_PFN    (contig_page_data.bdata->node_low_pfn)
 
        max_mapnr = num_physpages = MAX_LOW_PFN - START_PFN;
 
                pg_data_t *pgdat = NODE_DATA(nid);
                unsigned long low, start_pfn;
 
-               start_pfn = pgdat->bdata->node_boot_start >> PAGE_SHIFT;
+               start_pfn = pgdat->bdata->node_min_pfn;
                low = pgdat->bdata->node_low_pfn;
 
                if (max_zone_pfns[ZONE_NORMAL] < low)
 
  * memory pages (including holes) on the node.
  */
 typedef struct bootmem_data {
-       unsigned long node_boot_start;
+       unsigned long node_min_pfn;
        unsigned long node_low_pfn;
        void *node_bootmem_map;
        unsigned long last_end_off;
 
                bootmem_data_t *ent;
 
                ent = list_entry(iter, bootmem_data_t, list);
-               if (bdata->node_boot_start < ent->node_boot_start)
+               if (bdata->node_min_pfn < ent->node_min_pfn)
                        break;
        }
        list_add_tail(&bdata->list, iter);
 
        mminit_validate_memmodel_limits(&start, &end);
        bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));
-       bdata->node_boot_start = PFN_PHYS(start);
+       bdata->node_min_pfn = start;
        bdata->node_low_pfn = end;
        link_bootmem(bdata);
 
        if (!bdata->node_bootmem_map)
                return 0;
 
-       start = PFN_DOWN(bdata->node_boot_start);
+       start = bdata->node_min_pfn;
        end = bdata->node_low_pfn;
 
        /*
                unsigned long *map, idx, vec;
 
                map = bdata->node_bootmem_map;
-               idx = start - PFN_DOWN(bdata->node_boot_start);
+               idx = start - bdata->node_min_pfn;
                vec = ~map[idx / BITS_PER_LONG];
 
                if (aligned && vec == ~0UL && start + BITS_PER_LONG < end) {
        }
 
        page = virt_to_page(bdata->node_bootmem_map);
-       pages = bdata->node_low_pfn - PFN_DOWN(bdata->node_boot_start);
+       pages = bdata->node_low_pfn - bdata->node_min_pfn;
        pages = bootmem_bootmap_pages(pages);
        count += pages;
        while (pages--)
        unsigned long idx;
 
        bdebug("nid=%td start=%lx end=%lx\n", bdata - bootmem_node_data,
-               sidx + PFN_DOWN(bdata->node_boot_start),
-               eidx + PFN_DOWN(bdata->node_boot_start));
+               sidx + bdata->node_min_pfn,
+               eidx + bdata->node_min_pfn);
 
        if (bdata->hint_idx > sidx)
                bdata->hint_idx = sidx;
 
        bdebug("nid=%td start=%lx end=%lx flags=%x\n",
                bdata - bootmem_node_data,
-               sidx + PFN_DOWN(bdata->node_boot_start),
-               eidx + PFN_DOWN(bdata->node_boot_start),
+               sidx + bdata->node_min_pfn,
+               eidx + bdata->node_min_pfn,
                flags);
 
        for (idx = sidx; idx < eidx; idx++)
                                return -EBUSY;
                        }
                        bdebug("silent double reserve of PFN %lx\n",
-                               idx + PFN_DOWN(bdata->node_boot_start));
+                               idx + bdata->node_min_pfn);
                }
        return 0;
 }
        bdebug("nid=%td start=%lx end=%lx reserve=%d flags=%x\n",
                bdata - bootmem_node_data, start, end, reserve, flags);
 
-       BUG_ON(start < PFN_DOWN(bdata->node_boot_start));
+       BUG_ON(start < bdata->node_min_pfn);
        BUG_ON(end > bdata->node_low_pfn);
 
-       sidx = start - PFN_DOWN(bdata->node_boot_start);
-       eidx = end - PFN_DOWN(bdata->node_boot_start);
+       sidx = start - bdata->node_min_pfn;
+       eidx = end - bdata->node_min_pfn;
 
        if (reserve)
                return __reserve(bdata, sidx, eidx, flags);
                int err;
                unsigned long max;
 
-               if (pos < PFN_DOWN(bdata->node_boot_start)) {
+               if (pos < bdata->node_min_pfn ||
+                   pos >= bdata->node_low_pfn) {
                        BUG_ON(pos != start);
                        continue;
                }
                bdata - bootmem_node_data, size, PAGE_ALIGN(size) >> PAGE_SHIFT,
                align, goal, limit);
 
-       min = PFN_DOWN(bdata->node_boot_start);
+       min = bdata->node_min_pfn;
        max = bdata->node_low_pfn;
 
        goal >>= PAGE_SHIFT;
        else
                start = ALIGN(min, step);
 
-       sidx = start - PFN_DOWN(bdata->node_boot_start);
-       midx = max - PFN_DOWN(bdata->node_boot_start);
+       sidx = start - bdata->node_min_pfn;;
+       midx = max - bdata->node_min_pfn;
 
        if (bdata->hint_idx > sidx) {
                /*
                                PFN_UP(end_off), BOOTMEM_EXCLUSIVE))
                        BUG();
 
-               region = phys_to_virt(bdata->node_boot_start + start_off);
+               region = phys_to_virt(PFN_PHYS(bdata->node_min_pfn) +
+                               start_off);
                memset(region, 0, size);
                return region;
        }
 
                if (goal && bdata->node_low_pfn <= PFN_DOWN(goal))
                        continue;
-               if (limit && bdata->node_boot_start >= limit)
+               if (limit && bdata->node_min_pfn >= PFN_DOWN(limit))
                        break;
 
                region = alloc_bootmem_core(bdata, size, align, goal, limit);