Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel26-alx/patches-2.6.20-r6/0116-2.6.20.16-all-fixes.patch

    Contents of /trunk/kernel26-alx/patches-2.6.20-r6/0116-2.6.20.16-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 1175 - (show annotations) (download)
    Thu Oct 14 12:15:46 2010 UTC (13 years, 6 months ago) by niro
    File size: 34527 byte(s) 
    -2.6.20-alx-r6 new magellan 0.5.2 kernel
    1 diff --git a/arch/i386/kernel/entry.S b/arch/i386/kernel/entry.S
    2 index 5e47683..9bf056e 100644
    3 --- a/arch/i386/kernel/entry.S
    4 +++ b/arch/i386/kernel/entry.S
    5 @@ -367,10 +367,6 @@ ENTRY(system_call)
    6 CFI_ADJUST_CFA_OFFSET 4
    7 SAVE_ALL
    8 GET_THREAD_INFO(%ebp)
    9 - testl $TF_MASK,PT_EFLAGS(%esp)
    10 - jz no_singlestep
    11 - orl $_TIF_SINGLESTEP,TI_flags(%ebp)
    12 -no_singlestep:
    13 # system call tracing in operation / emulation
    14 /* Note, _TIF_SECCOMP is bit number 8, and so it needs testw and not testb */
    15 testw $(_TIF_SYSCALL_EMU|_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT),TI_flags(%ebp)
    16 @@ -385,6 +381,10 @@ syscall_exit:
    17 # setting need_resched or sigpending
    18 # between sampling and the iret
    19 TRACE_IRQS_OFF
    20 + testl $TF_MASK,PT_EFLAGS(%esp) # If tracing set singlestep flag on exit
    21 + jz no_singlestep
    22 + orl $_TIF_SINGLESTEP,TI_flags(%ebp)
    23 +no_singlestep:
    24 movl TI_flags(%ebp), %ecx
    25 testw $_TIF_ALLWORK_MASK, %cx # current->work
    26 jne syscall_exit_work
    27 diff --git a/arch/i386/oprofile/nmi_int.c b/arch/i386/oprofile/nmi_int.c
    28 index 3700eef..be4a9a8 100644
    29 --- a/arch/i386/oprofile/nmi_int.c
    30 +++ b/arch/i386/oprofile/nmi_int.c
    31 @@ -131,7 +131,6 @@ static void nmi_save_registers(void * dummy)
    32 {
    33 int cpu = smp_processor_id();
    34 struct op_msrs * msrs = &cpu_msrs[cpu];
    35 - model->fill_in_addresses(msrs);
    36 nmi_cpu_save_registers(msrs);
    37 }
    38
    39 @@ -195,6 +194,7 @@ static struct notifier_block profile_exceptions_nb = {
    40 static int nmi_setup(void)
    41 {
    42 int err=0;
    43 + int cpu;
    44
    45 if (!allocate_msrs())
    46 return -ENOMEM;
    47 @@ -207,6 +207,13 @@ static int nmi_setup(void)
    48 /* We need to serialize save and setup for HT because the subset
    49 * of msrs are distinct for save and setup operations
    50 */
    51 +
    52 + /* Assume saved/restored counters are the same on all CPUs */
    53 + model->fill_in_addresses(&cpu_msrs[0]);
    54 + for_each_possible_cpu (cpu) {
    55 + if (cpu != 0)
    56 + cpu_msrs[cpu] = cpu_msrs[0];
    57 + }
    58 on_each_cpu(nmi_save_registers, NULL, 0, 1);
    59 on_each_cpu(nmi_cpu_setup, NULL, 0, 1);
    60 nmi_enabled = 1;
    61 diff --git a/arch/powerpc/kernel/signal_64.c b/arch/powerpc/kernel/signal_64.c
    62 index f72e8e8..a84304e 100644
    63 --- a/arch/powerpc/kernel/signal_64.c
    64 +++ b/arch/powerpc/kernel/signal_64.c
    65 @@ -177,6 +177,13 @@ static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
    66 */
    67 discard_lazy_cpu_state();
    68
    69 + /*
    70 + * Force reload of FP/VEC.
    71 + * This has to be done before copying stuff into current->thread.fpr/vr
    72 + * for the reasons explained in the previous comment.
    73 + */
    74 + regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC);
    75 +
    76 err |= __copy_from_user(&current->thread.fpr, &sc->fp_regs, FP_REGS_SIZE);
    77
    78 #ifdef CONFIG_ALTIVEC
    79 @@ -198,9 +205,6 @@ static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
    80 current->thread.vrsave = 0;
    81 #endif /* CONFIG_ALTIVEC */
    82
    83 - /* Force reload of FP/VEC */
    84 - regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC);
    85 -
    86 return err;
    87 }
    88
    89 diff --git a/arch/x86_64/mm/init.c b/arch/x86_64/mm/init.c
    90 index 2968b90..e67cc4f 100644
    91 --- a/arch/x86_64/mm/init.c
    92 +++ b/arch/x86_64/mm/init.c
    93 @@ -72,6 +72,8 @@ void show_mem(void)
    94
    95 for_each_online_pgdat(pgdat) {
    96 for (i = 0; i < pgdat->node_spanned_pages; ++i) {
    97 + if (!pfn_valid(pgdat->node_start_pfn + i))
    98 + continue;
    99 page = pfn_to_page(pgdat->node_start_pfn + i);
    100 total++;
    101 if (PageReserved(page))
    102 @@ -766,3 +768,9 @@ int in_gate_area_no_task(unsigned long addr)
    103 {
    104 return (addr >= VSYSCALL_START) && (addr < VSYSCALL_END);
    105 }
    106 +
    107 +void *alloc_bootmem_high_node(pg_data_t *pgdat, unsigned long size)
    108 +{
    109 + return __alloc_bootmem_core(pgdat->bdata, size,
    110 + SMP_CACHE_BYTES, (4UL*1024*1024*1024), 0);
    111 +}
    112 diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
    113 index 3ffa080..e4e0ccb 100644
    114 --- a/drivers/char/cyclades.c
    115 +++ b/drivers/char/cyclades.c
    116 @@ -1102,6 +1102,7 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
    117
    118 if (data & info->ignore_status_mask) {
    119 info->icount.rx++;
    120 + spin_unlock(&cinfo->card_lock);
    121 return;
    122 }
    123 if (tty_buffer_request_room(tty, 1)) {
    124 diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
    125 index cef1287..550ac72 100644
    126 --- a/drivers/md/bitmap.c
    127 +++ b/drivers/md/bitmap.c
    128 @@ -255,19 +255,25 @@ static struct page *read_sb_page(mddev_t *mddev, long offset, unsigned long inde
    129
    130 }
    131
    132 -static int write_sb_page(mddev_t *mddev, long offset, struct page *page, int wait)
    133 +static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
    134 {
    135 mdk_rdev_t *rdev;
    136 struct list_head *tmp;
    137 + mddev_t *mddev = bitmap->mddev;
    138
    139 ITERATE_RDEV(mddev, rdev, tmp)
    140 if (test_bit(In_sync, &rdev->flags)
    141 - && !test_bit(Faulty, &rdev->flags))
    142 + && !test_bit(Faulty, &rdev->flags)) {
    143 + int size = PAGE_SIZE;
    144 + if (page->index == bitmap->file_pages-1)
    145 + size = roundup(bitmap->last_page_size,
    146 + bdev_hardsect_size(rdev->bdev));
    147 md_super_write(mddev, rdev,
    148 - (rdev->sb_offset<<1) + offset
    149 + (rdev->sb_offset<<1) + bitmap->offset
    150 + page->index * (PAGE_SIZE/512),
    151 - PAGE_SIZE,
    152 + size,
    153 page);
    154 + }
    155
    156 if (wait)
    157 md_super_wait(mddev);
    158 @@ -282,7 +288,7 @@ static int write_page(struct bitmap *bitmap, struct page *page, int wait)
    159 struct buffer_head *bh;
    160
    161 if (bitmap->file == NULL)
    162 - return write_sb_page(bitmap->mddev, bitmap->offset, page, wait);
    163 + return write_sb_page(bitmap, page, wait);
    164
    165 bh = page_buffers(page);
    166
    167 @@ -923,6 +929,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
    168 }
    169
    170 bitmap->filemap[bitmap->file_pages++] = page;
    171 + bitmap->last_page_size = count;
    172 }
    173 paddr = kmap_atomic(page, KM_USER0);
    174 if (bitmap->flags & BITMAP_HOSTENDIAN)
    175 diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
    176 index 4c2471e..b9ff4e3 100644
    177 --- a/drivers/md/dm-crypt.c
    178 +++ b/drivers/md/dm-crypt.c
    179 @@ -33,7 +33,6 @@
    180 struct crypt_io {
    181 struct dm_target *target;
    182 struct bio *base_bio;
    183 - struct bio *first_clone;
    184 struct work_struct work;
    185 atomic_t pending;
    186 int error;
    187 @@ -107,6 +106,8 @@ struct crypt_config {
    188
    189 static struct kmem_cache *_crypt_io_pool;
    190
    191 +static void clone_init(struct crypt_io *, struct bio *);
    192 +
    193 /*
    194 * Different IV generation algorithms:
    195 *
    196 @@ -378,25 +379,20 @@ static int crypt_convert(struct crypt_config *cc,
    197 * This should never violate the device limitations
    198 * May return a smaller bio when running out of pages
    199 */
    200 -static struct bio *
    201 -crypt_alloc_buffer(struct crypt_config *cc, unsigned int size,
    202 - struct bio *base_bio, unsigned int *bio_vec_idx)
    203 +static struct bio *crypt_alloc_buffer(struct crypt_io *io, unsigned int size,
    204 + unsigned int *bio_vec_idx)
    205 {
    206 + struct crypt_config *cc = io->target->private;
    207 struct bio *clone;
    208 unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
    209 gfp_t gfp_mask = GFP_NOIO | __GFP_HIGHMEM;
    210 unsigned int i;
    211
    212 - if (base_bio) {
    213 - clone = bio_alloc_bioset(GFP_NOIO, base_bio->bi_max_vecs, cc->bs);
    214 - __bio_clone(clone, base_bio);
    215 - } else
    216 - clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
    217 -
    218 + clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
    219 if (!clone)
    220 return NULL;
    221
    222 - clone->bi_destructor = dm_crypt_bio_destructor;
    223 + clone_init(io, clone);
    224
    225 /* if the last bio was not complete, continue where that one ended */
    226 clone->bi_idx = *bio_vec_idx;
    227 @@ -495,9 +491,6 @@ static void dec_pending(struct crypt_io *io, int error)
    228 if (!atomic_dec_and_test(&io->pending))
    229 return;
    230
    231 - if (io->first_clone)
    232 - bio_put(io->first_clone);
    233 -
    234 bio_endio(io->base_bio, io->base_bio->bi_size, io->error);
    235
    236 mempool_free(io, cc->io_pool);
    237 @@ -562,6 +555,7 @@ static void clone_init(struct crypt_io *io, struct bio *clone)
    238 clone->bi_end_io = crypt_endio;
    239 clone->bi_bdev = cc->dev->bdev;
    240 clone->bi_rw = io->base_bio->bi_rw;
    241 + clone->bi_destructor = dm_crypt_bio_destructor;
    242 }
    243
    244 static void process_read(struct crypt_io *io)
    245 @@ -585,7 +579,6 @@ static void process_read(struct crypt_io *io)
    246 }
    247
    248 clone_init(io, clone);
    249 - clone->bi_destructor = dm_crypt_bio_destructor;
    250 clone->bi_idx = 0;
    251 clone->bi_vcnt = bio_segments(base_bio);
    252 clone->bi_size = base_bio->bi_size;
    253 @@ -615,8 +608,7 @@ static void process_write(struct crypt_io *io)
    254 * so repeat the whole process until all the data can be handled.
    255 */
    256 while (remaining) {
    257 - clone = crypt_alloc_buffer(cc, base_bio->bi_size,
    258 - io->first_clone, &bvec_idx);
    259 + clone = crypt_alloc_buffer(io, base_bio->bi_size, &bvec_idx);
    260 if (unlikely(!clone)) {
    261 dec_pending(io, -ENOMEM);
    262 return;
    263 @@ -631,31 +623,23 @@ static void process_write(struct crypt_io *io)
    264 return;
    265 }
    266
    267 - clone_init(io, clone);
    268 clone->bi_sector = cc->start + sector;
    269 -
    270 - if (!io->first_clone) {
    271 - /*
    272 - * hold a reference to the first clone, because it
    273 - * holds the bio_vec array and that can't be freed
    274 - * before all other clones are released
    275 - */
    276 - bio_get(clone);
    277 - io->first_clone = clone;
    278 - }
    279 -
    280 remaining -= clone->bi_size;
    281 sector += bio_sectors(clone);
    282
    283 - /* prevent bio_put of first_clone */
    284 + /* Grab another reference to the io struct
    285 + * before we kick off the request */
    286 if (remaining)
    287 atomic_inc(&io->pending);
    288
    289 generic_make_request(clone);
    290
    291 + /* Do not reference clone after this - it
    292 + * may be gone already. */
    293 +
    294 /* out of memory -> run queues */
    295 if (remaining)
    296 - congestion_wait(bio_data_dir(clone), HZ/100);
    297 + congestion_wait(WRITE, HZ/100);
    298 }
    299 }
    300
    301 @@ -954,10 +938,12 @@ static int crypt_map(struct dm_target *ti, struct bio *bio,
    302 struct crypt_config *cc = ti->private;
    303 struct crypt_io *io;
    304
    305 + if (bio_barrier(bio))
    306 + return -EOPNOTSUPP;
    307 +
    308 io = mempool_alloc(cc->io_pool, GFP_NOIO);
    309 io->target = ti;
    310 io->base_bio = bio;
    311 - io->first_clone = NULL;
    312 io->error = io->post_process = 0;
    313 atomic_set(&io->pending, 0);
    314 kcryptd_queue_io(io);
    315 diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
    316 index dfe3214..2c404f7 100644
    317 --- a/drivers/md/raid0.c
    318 +++ b/drivers/md/raid0.c
    319 @@ -415,7 +415,7 @@ static int raid0_make_request (request_queue_t *q, struct bio *bio)
    320 raid0_conf_t *conf = mddev_to_conf(mddev);
    321 struct strip_zone *zone;
    322 mdk_rdev_t *tmp_dev;
    323 - unsigned long chunk;
    324 + sector_t chunk;
    325 sector_t block, rsect;
    326 const int rw = bio_data_dir(bio);
    327
    328 @@ -470,7 +470,6 @@ static int raid0_make_request (request_queue_t *q, struct bio *bio)
    329
    330 sector_div(x, zone->nb_dev);
    331 chunk = x;
    332 - BUG_ON(x != (sector_t)chunk);
    333
    334 x = block >> chunksize_bits;
    335 tmp_dev = zone->dev[sector_div(x, zone->nb_dev)];
    336 diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
    337 index 97ee870..b20c6e9 100644
    338 --- a/drivers/md/raid1.c
    339 +++ b/drivers/md/raid1.c
    340 @@ -1235,17 +1235,24 @@ static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
    341 }
    342 r1_bio->read_disk = primary;
    343 for (i=0; i<mddev->raid_disks; i++)
    344 - if (r1_bio->bios[i]->bi_end_io == end_sync_read &&
    345 - test_bit(BIO_UPTODATE, &r1_bio->bios[i]->bi_flags)) {
    346 + if (r1_bio->bios[i]->bi_end_io == end_sync_read) {
    347 int j;
    348 int vcnt = r1_bio->sectors >> (PAGE_SHIFT- 9);
    349 struct bio *pbio = r1_bio->bios[primary];
    350 struct bio *sbio = r1_bio->bios[i];
    351 - for (j = vcnt; j-- ; )
    352 - if (memcmp(page_address(pbio->bi_io_vec[j].bv_page),
    353 - page_address(sbio->bi_io_vec[j].bv_page),
    354 - PAGE_SIZE))
    355 - break;
    356 +
    357 + if (test_bit(BIO_UPTODATE, &sbio->bi_flags)) {
    358 + for (j = vcnt; j-- ; ) {
    359 + struct page *p, *s;
    360 + p = pbio->bi_io_vec[j].bv_page;
    361 + s = sbio->bi_io_vec[j].bv_page;
    362 + if (memcmp(page_address(p),
    363 + page_address(s),
    364 + PAGE_SIZE))
    365 + break;
    366 + }
    367 + } else
    368 + j = 0;
    369 if (j >= 0)
    370 mddev->resync_mismatches += r1_bio->sectors;
    371 if (j < 0 || test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
    372 diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
    373 index 82249a6..9eb66c1 100644
    374 --- a/drivers/md/raid10.c
    375 +++ b/drivers/md/raid10.c
    376 @@ -1867,6 +1867,7 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
    377 int d = r10_bio->devs[i].devnum;
    378 bio = r10_bio->devs[i].bio;
    379 bio->bi_end_io = NULL;
    380 + clear_bit(BIO_UPTODATE, &bio->bi_flags);
    381 if (conf->mirrors[d].rdev == NULL ||
    382 test_bit(Faulty, &conf->mirrors[d].rdev->flags))
    383 continue;
    384 @@ -2037,6 +2038,11 @@ static int run(mddev_t *mddev)
    385 /* 'size' is now the number of chunks in the array */
    386 /* calculate "used chunks per device" in 'stride' */
    387 stride = size * conf->copies;
    388 +
    389 + /* We need to round up when dividing by raid_disks to
    390 + * get the stride size.
    391 + */
    392 + stride += conf->raid_disks - 1;
    393 sector_div(stride, conf->raid_disks);
    394 mddev->size = stride << (conf->chunk_shift-1);
    395
    396 diff --git a/drivers/media/video/saa7134/saa7134-tvaudio.c b/drivers/media/video/saa7134/saa7134-tvaudio.c
    397 index dd759d6..36b3fa3 100644
    398 --- a/drivers/media/video/saa7134/saa7134-tvaudio.c
    399 +++ b/drivers/media/video/saa7134/saa7134-tvaudio.c
    400 @@ -1006,7 +1006,7 @@ int saa7134_tvaudio_init2(struct saa7134_dev *dev)
    401 int saa7134_tvaudio_fini(struct saa7134_dev *dev)
    402 {
    403 /* shutdown tvaudio thread */
    404 - if (dev->thread.pid >= 0) {
    405 + if (dev->thread.pid > 0) {
    406 dev->thread.shutdown = 1;
    407 wake_up_interruptible(&dev->thread.wq);
    408 wait_for_completion(&dev->thread.exit);
    409 diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
    410 index c6259c7..40bdcf9 100644
    411 --- a/drivers/net/e1000/e1000_main.c
    412 +++ b/drivers/net/e1000/e1000_main.c
    413 @@ -1157,13 +1157,16 @@ e1000_probe(struct pci_dev *pdev,
    414 !e1000_check_mng_mode(&adapter->hw))
    415 e1000_get_hw_control(adapter);
    416
    417 - strcpy(netdev->name, "eth%d");
    418 - if ((err = register_netdev(netdev)))
    419 - goto err_register;
    420 -
    421 /* tell the stack to leave us alone until e1000_open() is called */
    422 netif_carrier_off(netdev);
    423 netif_stop_queue(netdev);
    424 +#ifdef CONFIG_E1000_NAPI
    425 + netif_poll_disable(netdev);
    426 +#endif
    427 +
    428 + strcpy(netdev->name, "eth%d");
    429 + if ((err = register_netdev(netdev)))
    430 + goto err_register;
    431
    432 DPRINTK(PROBE, INFO, "Intel(R) PRO/1000 Network Connection\n");
    433
    434 diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
    435 index 38e75cf..aec8c59 100644
    436 --- a/drivers/net/sky2.c
    437 +++ b/drivers/net/sky2.c
    438 @@ -95,7 +95,7 @@ static int disable_msi = 0;
    439 module_param(disable_msi, int, 0);
    440 MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
    441
    442 -static int idle_timeout = 0;
    443 +static int idle_timeout = 100;
    444 module_param(idle_timeout, int, 0);
    445 MODULE_PARM_DESC(idle_timeout, "Watchdog timer for lost interrupts (ms)");
    446
    447 @@ -2341,6 +2341,13 @@ static int sky2_poll(struct net_device *dev0, int *budget)
    448
    449 work_done = sky2_status_intr(hw, work_limit);
    450 if (work_done < work_limit) {
    451 + /* Bug/Errata workaround?
    452 + * Need to kick the TX irq moderation timer.
    453 + */
    454 + if (sky2_read8(hw, STAT_TX_TIMER_CTRL) == TIM_START) {
    455 + sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP);
    456 + sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START);
    457 + }
    458 netif_rx_complete(dev0);
    459
    460 sky2_read32(hw, B0_Y2_SP_LISR);
    461 diff --git a/drivers/serial/mpsc.c b/drivers/serial/mpsc.c
    462 index 3d2fcc5..64ed5ef 100644
    463 --- a/drivers/serial/mpsc.c
    464 +++ b/drivers/serial/mpsc.c
    465 @@ -502,7 +502,8 @@ mpsc_sdma_intr_ack(struct mpsc_port_info *pi)
    466
    467 if (pi->mirror_regs)
    468 pi->shared_regs->SDMA_INTR_CAUSE_m = 0;
    469 - writel(0, pi->shared_regs->sdma_intr_base + SDMA_INTR_CAUSE);
    470 + writeb(0x00, pi->shared_regs->sdma_intr_base + SDMA_INTR_CAUSE +
    471 + pi->port.line);
    472 return;
    473 }
    474
    475 diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
    476 index 2275f27..8f820e4 100644
    477 --- a/include/linux/bootmem.h
    478 +++ b/include/linux/bootmem.h
    479 @@ -59,6 +59,7 @@ extern void *__alloc_bootmem_core(struct bootmem_data *bdata,
    480 unsigned long align,
    481 unsigned long goal,
    482 unsigned long limit);
    483 +extern void *alloc_bootmem_high_node(pg_data_t *pgdat, unsigned long size);
    484
    485 #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
    486 extern void reserve_bootmem(unsigned long addr, unsigned long size);
    487 diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
    488 index d37f46a..f768e10 100644
    489 --- a/include/linux/pci_ids.h
    490 +++ b/include/linux/pci_ids.h
    491 @@ -2235,11 +2235,11 @@
    492 #define PCI_DEVICE_ID_INTEL_ICH8_5 0x283e
    493 #define PCI_DEVICE_ID_INTEL_ICH8_6 0x2850
    494 #define PCI_DEVICE_ID_INTEL_ICH9_0 0x2910
    495 -#define PCI_DEVICE_ID_INTEL_ICH9_1 0x2911
    496 +#define PCI_DEVICE_ID_INTEL_ICH9_1 0x2917
    497 #define PCI_DEVICE_ID_INTEL_ICH9_2 0x2912
    498 #define PCI_DEVICE_ID_INTEL_ICH9_3 0x2913
    499 #define PCI_DEVICE_ID_INTEL_ICH9_4 0x2914
    500 -#define PCI_DEVICE_ID_INTEL_ICH9_5 0x2915
    501 +#define PCI_DEVICE_ID_INTEL_ICH9_5 0x2919
    502 #define PCI_DEVICE_ID_INTEL_ICH9_6 0x2930
    503 #define PCI_DEVICE_ID_INTEL_82855PM_HB 0x3340
    504 #define PCI_DEVICE_ID_INTEL_82830_HB 0x3575
    505 diff --git a/include/linux/raid/bitmap.h b/include/linux/raid/bitmap.h
    506 index 6db9a4c..dd5a05d 100644
    507 --- a/include/linux/raid/bitmap.h
    508 +++ b/include/linux/raid/bitmap.h
    509 @@ -232,6 +232,7 @@ struct bitmap {
    510 struct page **filemap; /* list of cache pages for the file */
    511 unsigned long *filemap_attr; /* attributes associated w/ filemap pages */
    512 unsigned long file_pages; /* number of pages in the file */
    513 + int last_page_size; /* bytes in the last page */
    514
    515 unsigned long flags;
    516
    517 diff --git a/include/linux/sched.h b/include/linux/sched.h
    518 index 4463735..7a0cc67 100644
    519 --- a/include/linux/sched.h
    520 +++ b/include/linux/sched.h
    521 @@ -1137,6 +1137,7 @@ static inline void put_task_struct(struct task_struct *t)
    522 /* Not implemented yet, only for 486*/
    523 #define PF_STARTING 0x00000002 /* being created */
    524 #define PF_EXITING 0x00000004 /* getting shut down */
    525 +#define PF_EXITPIDONE 0x00000008 /* pi exit done on shut down */
    526 #define PF_FORKNOEXEC 0x00000040 /* forked but didn't exec */
    527 #define PF_SUPERPRIV 0x00000100 /* used super-user privileges */
    528 #define PF_DUMPCORE 0x00000200 /* dumped core */
    529 diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
    530 index 2a7b38d..1a76bda 100644
    531 --- a/include/linux/workqueue.h
    532 +++ b/include/linux/workqueue.h
    533 @@ -162,7 +162,7 @@ extern struct workqueue_struct *__create_workqueue(const char *name,
    534 int singlethread,
    535 int freezeable);
    536 #define create_workqueue(name) __create_workqueue((name), 0, 0)
    537 -#define create_freezeable_workqueue(name) __create_workqueue((name), 0, 1)
    538 +#define create_freezeable_workqueue(name) __create_workqueue((name), 1, 1)
    539 #define create_singlethread_workqueue(name) __create_workqueue((name), 1, 0)
    540
    541 extern void destroy_workqueue(struct workqueue_struct *wq);
    542 diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
    543 index 9c8c232..5a75657 100644
    544 --- a/kernel/auditfilter.c
    545 +++ b/kernel/auditfilter.c
    546 @@ -905,7 +905,7 @@ static void audit_update_watch(struct audit_parent *parent,
    547
    548 /* If the update involves invalidating rules, do the inode-based
    549 * filtering now, so we don't omit records. */
    550 - if (invalidating &&
    551 + if (invalidating && current->audit_context &&
    552 audit_filter_inodes(current, current->audit_context) == AUDIT_RECORD_CONTEXT)
    553 audit_set_auditable(current->audit_context);
    554
    555 diff --git a/kernel/exit.c b/kernel/exit.c
    556 index fec12eb..d306845 100644
    557 --- a/kernel/exit.c
    558 +++ b/kernel/exit.c
    559 @@ -883,13 +883,29 @@ fastcall NORET_TYPE void do_exit(long code)
    560 if (unlikely(tsk->flags & PF_EXITING)) {
    561 printk(KERN_ALERT
    562 "Fixing recursive fault but reboot is needed!\n");
    563 + /*
    564 + * We can do this unlocked here. The futex code uses
    565 + * this flag just to verify whether the pi state
    566 + * cleanup has been done or not. In the worst case it
    567 + * loops once more. We pretend that the cleanup was
    568 + * done as there is no way to return. Either the
    569 + * OWNER_DIED bit is set by now or we push the blocked
    570 + * task into the wait for ever nirwana as well.
    571 + */
    572 + tsk->flags |= PF_EXITPIDONE;
    573 if (tsk->io_context)
    574 exit_io_context();
    575 set_current_state(TASK_UNINTERRUPTIBLE);
    576 schedule();
    577 }
    578
    579 + /*
    580 + * tsk->flags are checked in the futex code to protect against
    581 + * an exiting task cleaning up the robust pi futexes.
    582 + */
    583 + spin_lock_irq(&tsk->pi_lock);
    584 tsk->flags |= PF_EXITING;
    585 + spin_unlock_irq(&tsk->pi_lock);
    586
    587 if (unlikely(in_atomic()))
    588 printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
    589 @@ -956,6 +972,12 @@ fastcall NORET_TYPE void do_exit(long code)
    590 * Make sure we are holding no locks:
    591 */
    592 debug_check_no_locks_held(tsk);
    593 + /*
    594 + * We can do this unlocked here. The futex code uses this flag
    595 + * just to verify whether the pi state cleanup has been done
    596 + * or not. In the worst case it loops once more.
    597 + */
    598 + tsk->flags |= PF_EXITPIDONE;
    599
    600 if (tsk->io_context)
    601 exit_io_context();
    602 diff --git a/kernel/futex.c b/kernel/futex.c
    603 index 1df411e..99dad33 100644
    604 --- a/kernel/futex.c
    605 +++ b/kernel/futex.c
    606 @@ -390,18 +390,12 @@ static struct task_struct * futex_find_get_task(pid_t pid)
    607
    608 rcu_read_lock();
    609 p = find_task_by_pid(pid);
    610 - if (!p)
    611 - goto out_unlock;
    612 - if ((current->euid != p->euid) && (current->euid != p->uid)) {
    613 - p = NULL;
    614 - goto out_unlock;
    615 - }
    616 - if (p->exit_state != 0) {
    617 - p = NULL;
    618 - goto out_unlock;
    619 - }
    620 - get_task_struct(p);
    621 -out_unlock:
    622 +
    623 + if (!p || ((current->euid != p->euid) && (current->euid != p->uid)))
    624 + p = ERR_PTR(-ESRCH);
    625 + else
    626 + get_task_struct(p);
    627 +
    628 rcu_read_unlock();
    629
    630 return p;
    631 @@ -467,7 +461,7 @@ lookup_pi_state(u32 uval, struct futex_hash_bucket *hb, struct futex_q *me)
    632 struct futex_q *this, *next;
    633 struct list_head *head;
    634 struct task_struct *p;
    635 - pid_t pid;
    636 + pid_t pid = uval & FUTEX_TID_MASK;
    637
    638 head = &hb->chain;
    639
    640 @@ -485,6 +479,8 @@ lookup_pi_state(u32 uval, struct futex_hash_bucket *hb, struct futex_q *me)
    641 return -EINVAL;
    642
    643 WARN_ON(!atomic_read(&pi_state->refcount));
    644 + WARN_ON(pid && pi_state->owner &&
    645 + pi_state->owner->pid != pid);
    646
    647 atomic_inc(&pi_state->refcount);
    648 me->pi_state = pi_state;
    649 @@ -495,15 +491,33 @@ lookup_pi_state(u32 uval, struct futex_hash_bucket *hb, struct futex_q *me)
    650
    651 /*
    652 * We are the first waiter - try to look up the real owner and attach
    653 - * the new pi_state to it, but bail out when the owner died bit is set
    654 - * and TID = 0:
    655 + * the new pi_state to it, but bail out when TID = 0
    656 */
    657 - pid = uval & FUTEX_TID_MASK;
    658 - if (!pid && (uval & FUTEX_OWNER_DIED))
    659 + if (!pid)
    660 return -ESRCH;
    661 p = futex_find_get_task(pid);
    662 - if (!p)
    663 - return -ESRCH;
    664 + if (IS_ERR(p))
    665 + return PTR_ERR(p);
    666 +
    667 + /*
    668 + * We need to look at the task state flags to figure out,
    669 + * whether the task is exiting. To protect against the do_exit
    670 + * change of the task flags, we do this protected by
    671 + * p->pi_lock:
    672 + */
    673 + spin_lock_irq(&p->pi_lock);
    674 + if (unlikely(p->flags & PF_EXITING)) {
    675 + /*
    676 + * The task is on the way out. When PF_EXITPIDONE is
    677 + * set, we know that the task has finished the
    678 + * cleanup:
    679 + */
    680 + int ret = (p->flags & PF_EXITPIDONE) ? -ESRCH : -EAGAIN;
    681 +
    682 + spin_unlock_irq(&p->pi_lock);
    683 + put_task_struct(p);
    684 + return ret;
    685 + }
    686
    687 pi_state = alloc_pi_state();
    688
    689 @@ -516,7 +530,6 @@ lookup_pi_state(u32 uval, struct futex_hash_bucket *hb, struct futex_q *me)
    690 /* Store the key for possible exit cleanups: */
    691 pi_state->key = me->key;
    692
    693 - spin_lock_irq(&p->pi_lock);
    694 WARN_ON(!list_empty(&pi_state->list));
    695 list_add(&pi_state->list, &p->pi_state_list);
    696 pi_state->owner = p;
    697 @@ -583,15 +596,22 @@ static int wake_futex_pi(u32 __user *uaddr, u32 uval, struct futex_q *this)
    698 * preserve the owner died bit.)
    699 */
    700 if (!(uval & FUTEX_OWNER_DIED)) {
    701 + int ret = 0;
    702 +
    703 newval = FUTEX_WAITERS | new_owner->pid;
    704
    705 pagefault_disable();
    706 curval = futex_atomic_cmpxchg_inatomic(uaddr, uval, newval);
    707 pagefault_enable();
    708 +
    709 if (curval == -EFAULT)
    710 - return -EFAULT;
    711 + ret = -EFAULT;
    712 if (curval != uval)
    713 - return -EINVAL;
    714 + ret = -EINVAL;
    715 + if (ret) {
    716 + spin_unlock(&pi_state->pi_mutex.wait_lock);
    717 + return ret;
    718 + }
    719 }
    720
    721 spin_lock_irq(&pi_state->owner->pi_lock);
    722 @@ -1149,6 +1169,7 @@ static int futex_lock_pi(u32 __user *uaddr, int detect, unsigned long sec,
    723 if (unlikely(ret != 0))
    724 goto out_release_sem;
    725
    726 + retry_unlocked:
    727 hb = queue_lock(&q, -1, NULL);
    728
    729 retry_locked:
    730 @@ -1200,34 +1221,58 @@ static int futex_lock_pi(u32 __user *uaddr, int detect, unsigned long sec,
    731 ret = lookup_pi_state(uval, hb, &q);
    732
    733 if (unlikely(ret)) {
    734 - /*
    735 - * There were no waiters and the owner task lookup
    736 - * failed. When the OWNER_DIED bit is set, then we
    737 - * know that this is a robust futex and we actually
    738 - * take the lock. This is safe as we are protected by
    739 - * the hash bucket lock. We also set the waiters bit
    740 - * unconditionally here, to simplify glibc handling of
    741 - * multiple tasks racing to acquire the lock and
    742 - * cleanup the problems which were left by the dead
    743 - * owner.
    744 - */
    745 - if (curval & FUTEX_OWNER_DIED) {
    746 - uval = newval;
    747 - newval = current->pid |
    748 - FUTEX_OWNER_DIED | FUTEX_WAITERS;
    749 + switch (ret) {
    750
    751 - pagefault_disable();
    752 - curval = futex_atomic_cmpxchg_inatomic(uaddr,
    753 - uval, newval);
    754 - pagefault_enable();
    755 + case -EAGAIN:
    756 + /*
    757 + * Task is exiting and we just wait for the
    758 + * exit to complete.
    759 + */
    760 + queue_unlock(&q, hb);
    761 + up_read(&curr->mm->mmap_sem);
    762 + cond_resched();
    763 + goto retry;
    764
    765 - if (unlikely(curval == -EFAULT))
    766 + case -ESRCH:
    767 + /*
    768 + * No owner found for this futex. Check if the
    769 + * OWNER_DIED bit is set to figure out whether
    770 + * this is a robust futex or not.
    771 + */
    772 + if (get_futex_value_locked(&curval, uaddr))
    773 goto uaddr_faulted;
    774 - if (unlikely(curval != uval))
    775 - goto retry_locked;
    776 - ret = 0;
    777 +
    778 + /*
    779 + * There were no waiters and the owner task lookup
    780 + * failed. When the OWNER_DIED bit is set, then we
    781 + * know that this is a robust futex and we actually
    782 + * take the lock. This is safe as we are protected by
    783 + * the hash bucket lock. We also set the waiters bit
    784 + * unconditionally here, to simplify glibc handling of
    785 + * multiple tasks racing to acquire the lock and
    786 + * cleanup the problems which were left by the dead
    787 + * owner.
    788 + */
    789 + if (curval & FUTEX_OWNER_DIED) {
    790 + uval = newval;
    791 + newval = current->pid |
    792 + FUTEX_OWNER_DIED | FUTEX_WAITERS;
    793 +
    794 + pagefault_disable();
    795 + curval = futex_atomic_cmpxchg_inatomic(uaddr,
    796 + uval,
    797 + newval);
    798 + pagefault_enable();
    799 +
    800 + if (unlikely(curval == -EFAULT))
    801 + goto uaddr_faulted;
    802 + if (unlikely(curval != uval))
    803 + goto retry_locked;
    804 + ret = 0;
    805 + }
    806 + default:
    807 + goto out_unlock_release_sem;
    808 }
    809 - goto out_unlock_release_sem;
    810 }
    811
    812 /*
    813 @@ -1279,39 +1324,52 @@ static int futex_lock_pi(u32 __user *uaddr, int detect, unsigned long sec,
    814 list_add(&q.pi_state->list, &current->pi_state_list);
    815 spin_unlock_irq(&current->pi_lock);
    816
    817 - /* Unqueue and drop the lock */
    818 - unqueue_me_pi(&q, hb);
    819 - up_read(&curr->mm->mmap_sem);
    820 /*
    821 * We own it, so we have to replace the pending owner
    822 - * TID. This must be atomic as we have preserve the
    823 + * TID. This must be atomic as we have to preserve the
    824 * owner died bit here.
    825 */
    826 - ret = get_user(uval, uaddr);
    827 + ret = get_futex_value_locked(&uval, uaddr);
    828 while (!ret) {
    829 newval = (uval & FUTEX_OWNER_DIED) | newtid;
    830 +
    831 + pagefault_disable();
    832 curval = futex_atomic_cmpxchg_inatomic(uaddr,
    833 uval, newval);
    834 + pagefault_enable();
    835 +
    836 if (curval == -EFAULT)
    837 ret = -EFAULT;
    838 if (curval == uval)
    839 break;
    840 uval = curval;
    841 }
    842 - } else {
    843 + } else if (ret) {
    844 /*
    845 * Catch the rare case, where the lock was released
    846 * when we were on the way back before we locked
    847 * the hash bucket.
    848 */
    849 - if (ret && q.pi_state->owner == curr) {
    850 - if (rt_mutex_trylock(&q.pi_state->pi_mutex))
    851 - ret = 0;
    852 + if (q.pi_state->owner == curr &&
    853 + rt_mutex_trylock(&q.pi_state->pi_mutex)) {
    854 + ret = 0;
    855 + } else {
    856 + /*
    857 + * Paranoia check. If we did not take the lock
    858 + * in the trylock above, then we should not be
    859 + * the owner of the rtmutex, neither the real
    860 + * nor the pending one:
    861 + */
    862 + if (rt_mutex_owner(&q.pi_state->pi_mutex) == curr)
    863 + printk(KERN_ERR "futex_lock_pi: ret = %d "
    864 + "pi-mutex: %p pi-state %p\n", ret,
    865 + q.pi_state->pi_mutex.owner,
    866 + q.pi_state->owner);
    867 }
    868 - /* Unqueue and drop the lock */
    869 - unqueue_me_pi(&q, hb);
    870 - up_read(&curr->mm->mmap_sem);
    871 }
    872 + /* Unqueue and drop the lock */
    873 + unqueue_me_pi(&q, hb);
    874 + up_read(&curr->mm->mmap_sem);
    875
    876 if (!detect && ret == -EDEADLK && 0)
    877 force_sig(SIGKILL, current);
    878 @@ -1331,16 +1389,18 @@ static int futex_lock_pi(u32 __user *uaddr, int detect, unsigned long sec,
    879 * non-atomically. Therefore, if get_user below is not
    880 * enough, we need to handle the fault ourselves, while
    881 * still holding the mmap_sem.
    882 + *
    883 + * ... and hb->lock. :-) --ANK
    884 */
    885 + queue_unlock(&q, hb);
    886 +
    887 if (attempt++) {
    888 - if (futex_handle_fault((unsigned long)uaddr, attempt)) {
    889 - ret = -EFAULT;
    890 - goto out_unlock_release_sem;
    891 - }
    892 - goto retry_locked;
    893 + ret = futex_handle_fault((unsigned long)uaddr, attempt);
    894 + if (ret)
    895 + goto out_release_sem;
    896 + goto retry_unlocked;
    897 }
    898
    899 - queue_unlock(&q, hb);
    900 up_read(&curr->mm->mmap_sem);
    901
    902 ret = get_user(uval, uaddr);
    903 @@ -1382,9 +1442,9 @@ retry:
    904 goto out;
    905
    906 hb = hash_futex(&key);
    907 +retry_unlocked:
    908 spin_lock(&hb->lock);
    909
    910 -retry_locked:
    911 /*
    912 * To avoid races, try to do the TID -> 0 atomic transition
    913 * again. If it succeeds then we can return without waking
    914 @@ -1446,16 +1506,17 @@ pi_faulted:
    915 * non-atomically. Therefore, if get_user below is not
    916 * enough, we need to handle the fault ourselves, while
    917 * still holding the mmap_sem.
    918 + *
    919 + * ... and hb->lock. :-) --ANK
    920 */
    921 + spin_unlock(&hb->lock);
    922 +
    923 if (attempt++) {
    924 - if (futex_handle_fault((unsigned long)uaddr, attempt)) {
    925 - ret = -EFAULT;
    926 - goto out_unlock;
    927 - }
    928 - goto retry_locked;
    929 + ret = futex_handle_fault((unsigned long)uaddr, attempt);
    930 + if (ret)
    931 + goto out;
    932 + goto retry_unlocked;
    933 }
    934 -
    935 - spin_unlock(&hb->lock);
    936 up_read(&current->mm->mmap_sem);
    937
    938 ret = get_user(uval, uaddr);
    939 diff --git a/kernel/rtmutex.c b/kernel/rtmutex.c
    940 index 4ab17da..dd5feae 100644
    941 --- a/kernel/rtmutex.c
    942 +++ b/kernel/rtmutex.c
    943 @@ -212,6 +212,19 @@ static int rt_mutex_adjust_prio_chain(struct task_struct *task,
    944 if (!waiter || !waiter->task)
    945 goto out_unlock_pi;
    946
    947 + /*
    948 + * Check the orig_waiter state. After we dropped the locks,
    949 + * the previous owner of the lock might have released the lock
    950 + * and made us the pending owner:
    951 + */
    952 + if (orig_waiter && !orig_waiter->task)
    953 + goto out_unlock_pi;
    954 +
    955 + /*
    956 + * Drop out, when the task has no waiters. Note,
    957 + * top_waiter can be NULL, when we are in the deboosting
    958 + * mode!
    959 + */
    960 if (top_waiter && (!task_has_pi_waiters(task) ||
    961 top_waiter != task_top_pi_waiter(task)))
    962 goto out_unlock_pi;
    963 @@ -659,9 +672,16 @@ rt_mutex_slowlock(struct rt_mutex *lock, int state,
    964 * all over without going into schedule to try
    965 * to get the lock now:
    966 */
    967 - if (unlikely(!waiter.task))
    968 + if (unlikely(!waiter.task)) {
    969 + /*
    970 + * Reset the return value. We might
    971 + * have returned with -EDEADLK and the
    972 + * owner released the lock while we
    973 + * were walking the pi chain.
    974 + */
    975 + ret = 0;
    976 continue;
    977 -
    978 + }
    979 if (unlikely(ret))
    980 break;
    981 }
    982 diff --git a/kernel/sched.c b/kernel/sched.c
    983 index 62db30c..907ab05 100644
    984 --- a/kernel/sched.c
    985 +++ b/kernel/sched.c
    986 @@ -2814,17 +2814,21 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
    987 unsigned long next_balance = jiffies + 60 * HZ;
    988
    989 for_each_domain(this_cpu, sd) {
    990 - if (sd->flags & SD_BALANCE_NEWIDLE) {
    991 + unsigned long interval;
    992 +
    993 + if (!(sd->flags & SD_LOAD_BALANCE))
    994 + continue;
    995 +
    996 + if (sd->flags & SD_BALANCE_NEWIDLE)
    997 /* If we've pulled tasks over stop searching: */
    998 pulled_task = load_balance_newidle(this_cpu,
    999 - this_rq, sd);
    1000 - if (time_after(next_balance,
    1001 - sd->last_balance + sd->balance_interval))
    1002 - next_balance = sd->last_balance
    1003 - + sd->balance_interval;
    1004 - if (pulled_task)
    1005 - break;
    1006 - }
    1007 + this_rq, sd);
    1008 +
    1009 + interval = msecs_to_jiffies(sd->balance_interval);
    1010 + if (time_after(next_balance, sd->last_balance + interval))
    1011 + next_balance = sd->last_balance + interval;
    1012 + if (pulled_task)
    1013 + break;
    1014 }
    1015 if (!pulled_task)
    1016 /*
    1017 diff --git a/mm/rmap.c b/mm/rmap.c
    1018 index 7ce69c1..c30781c 100644
    1019 --- a/mm/rmap.c
    1020 +++ b/mm/rmap.c
    1021 @@ -53,24 +53,6 @@
    1022
    1023 struct kmem_cache *anon_vma_cachep;
    1024
    1025 -static inline void validate_anon_vma(struct vm_area_struct *find_vma)
    1026 -{
    1027 -#ifdef CONFIG_DEBUG_VM
    1028 - struct anon_vma *anon_vma = find_vma->anon_vma;
    1029 - struct vm_area_struct *vma;
    1030 - unsigned int mapcount = 0;
    1031 - int found = 0;
    1032 -
    1033 - list_for_each_entry(vma, &anon_vma->head, anon_vma_node) {
    1034 - mapcount++;
    1035 - BUG_ON(mapcount > 100000);
    1036 - if (vma == find_vma)
    1037 - found = 1;
    1038 - }
    1039 - BUG_ON(!found);
    1040 -#endif
    1041 -}
    1042 -
    1043 /* This must be called under the mmap_sem. */
    1044 int anon_vma_prepare(struct vm_area_struct *vma)
    1045 {
    1046 @@ -121,10 +103,8 @@ void __anon_vma_link(struct vm_area_struct *vma)
    1047 {
    1048 struct anon_vma *anon_vma = vma->anon_vma;
    1049
    1050 - if (anon_vma) {
    1051 + if (anon_vma)
    1052 list_add_tail(&vma->anon_vma_node, &anon_vma->head);
    1053 - validate_anon_vma(vma);
    1054 - }
    1055 }
    1056
    1057 void anon_vma_link(struct vm_area_struct *vma)
    1058 @@ -134,7 +114,6 @@ void anon_vma_link(struct vm_area_struct *vma)
    1059 if (anon_vma) {
    1060 spin_lock(&anon_vma->lock);
    1061 list_add_tail(&vma->anon_vma_node, &anon_vma->head);
    1062 - validate_anon_vma(vma);
    1063 spin_unlock(&anon_vma->lock);
    1064 }
    1065 }
    1066 @@ -148,7 +127,6 @@ void anon_vma_unlink(struct vm_area_struct *vma)
    1067 return;
    1068
    1069 spin_lock(&anon_vma->lock);
    1070 - validate_anon_vma(vma);
    1071 list_del(&vma->anon_vma_node);
    1072
    1073 /* We must garbage collect the anon_vma if it's empty */
    1074 diff --git a/mm/sparse.c b/mm/sparse.c
    1075 index ac26eb0..faa08e2 100644
    1076 --- a/mm/sparse.c
    1077 +++ b/mm/sparse.c
    1078 @@ -209,6 +209,12 @@ static int sparse_init_one_section(struct mem_section *ms,
    1079 return 1;
    1080 }
    1081
    1082 +__attribute__((weak))
    1083 +void *alloc_bootmem_high_node(pg_data_t *pgdat, unsigned long size)
    1084 +{
    1085 + return NULL;
    1086 +}
    1087 +
    1088 static struct page *sparse_early_mem_map_alloc(unsigned long pnum)
    1089 {
    1090 struct page *map;
    1091 @@ -219,6 +225,11 @@ static struct page *sparse_early_mem_map_alloc(unsigned long pnum)
    1092 if (map)
    1093 return map;
    1094
    1095 + map = alloc_bootmem_high_node(NODE_DATA(nid),
    1096 + sizeof(struct page) * PAGES_PER_SECTION);
    1097 + if (map)
    1098 + return map;
    1099 +
    1100 map = alloc_bootmem_node(NODE_DATA(nid),
    1101 sizeof(struct page) * PAGES_PER_SECTION);
    1102 if (map)