Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'akpm' (patches from Andrew)
Merge misc fixes from Andrew Morton:
- "fork: unconditionally clear stack on fork" is a non-bugfix which got
lost during the merge window - performance concerns appear to have
been adequately addressed.
- and a bunch of fixes
* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
mm/filemap.c: fix NULL pointer in page_cache_tree_insert()
mm: memcg: add __GFP_NOWARN in __memcg_schedule_kmem_cache_create()
fs, elf: don't complain MAP_FIXED_NOREPLACE unless -EEXIST error
kexec_file: do not add extra alignment to efi memmap
proc: fix /proc/loadavg regression
proc: revalidate kernel thread inodes to root:root
autofs: mount point create should honour passed in mode
MAINTAINERS: add personal addresses for Sascha and Uwe
kasan: add no_sanitize attribute for clang builds
rapidio: fix rio_dma_transfer error handling
mm: enable thp migration for shmem thp
writeback: safer lock nesting
mm, pagemap: fix swap offset value for PMD migration entry
mm: fix do_pages_move status handling
fork: unconditionally clear stack on fork
+106
-72
+10
-5
MAINTAINERS
+10
-5
MAINTAINERS
···
1373
1373
F: drivers/net/ethernet/amd/am79c961a.*
1374
1374
1375
1375
ARM/ENERGY MICRO (SILICON LABS) EFM32 SUPPORT
1376
-
M: Uwe Kleine-König <kernel@pengutronix.de>
1376
+
M: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
1377
+
R: Pengutronix Kernel Team <kernel@pengutronix.de>
1377
1378
L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1378
1379
S: Maintained
1379
1380
N: efm32
···
1402
1401
1403
1402
ARM/FREESCALE IMX / MXC ARM ARCHITECTURE
1404
1403
M: Shawn Guo <shawnguo@kernel.org>
1405
-
M: Sascha Hauer <kernel@pengutronix.de>
1404
+
M: Sascha Hauer <s.hauer@pengutronix.de>
1405
+
R: Pengutronix Kernel Team <kernel@pengutronix.de>
1406
1406
R: Fabio Estevam <fabio.estevam@nxp.com>
1407
1407
L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1408
1408
S: Maintained
···
1418
1416
1419
1417
ARM/FREESCALE VYBRID ARM ARCHITECTURE
1420
1418
M: Shawn Guo <shawnguo@kernel.org>
1421
-
M: Sascha Hauer <kernel@pengutronix.de>
1419
+
M: Sascha Hauer <s.hauer@pengutronix.de>
1420
+
R: Pengutronix Kernel Team <kernel@pengutronix.de>
1422
1421
R: Stefan Agner <stefan@agner.ch>
1423
1422
L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
1424
1423
S: Maintained
···
5655
5652
F: Documentation/devicetree/bindings/net/fsl-fec.txt
5656
5653
5657
5654
FREESCALE IMX / MXC FRAMEBUFFER DRIVER
5658
-
M: Sascha Hauer <kernel@pengutronix.de>
5655
+
M: Sascha Hauer <s.hauer@pengutronix.de>
5656
+
R: Pengutronix Kernel Team <kernel@pengutronix.de>
5659
5657
L: linux-fbdev@vger.kernel.org
5660
5658
L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
5661
5659
S: Maintained
···
12829
12825
12830
12826
SIOX
12831
12827
M: Gavin Schenk <g.schenk@eckelmann.de>
12832
-
M: Uwe Kleine-König <kernel@pengutronix.de>
12828
+
M: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
12829
+
R: Pengutronix Kernel Team <kernel@pengutronix.de>
12833
12830
S: Supported
12834
12831
F: drivers/siox/*
12835
12832
F: include/trace/events/siox.h
+1
-1
arch/powerpc/platforms/cell/spufs/sched.c
+1
-1
arch/powerpc/platforms/cell/spufs/sched.c
+2
-3
arch/x86/kernel/kexec-bzimage64.c
+2
-3
arch/x86/kernel/kexec-bzimage64.c
···
398
398
* little bit simple
399
399
*/
400
400
efi_map_sz = efi_get_runtime_map_size();
401
-
efi_map_sz = ALIGN(efi_map_sz, 16);
402
401
params_cmdline_sz = sizeof(struct boot_params) + cmdline_len +
403
402
MAX_ELFCOREHDR_STR_LEN;
404
403
params_cmdline_sz = ALIGN(params_cmdline_sz, 16);
405
-
kbuf.bufsz = params_cmdline_sz + efi_map_sz +
404
+
kbuf.bufsz = params_cmdline_sz + ALIGN(efi_map_sz, 16) +
406
405
sizeof(struct setup_data) +
407
406
sizeof(struct efi_setup_data);
408
407
···
409
410
if (!params)
410
411
return ERR_PTR(-ENOMEM);
411
412
efi_map_offset = params_cmdline_sz;
412
-
efi_setup_data_offset = efi_map_offset + efi_map_sz;
413
+
efi_setup_data_offset = efi_map_offset + ALIGN(efi_map_sz, 16);
413
414
414
415
/* Copy setup header onto bootparams. Documentation/x86/boot.txt */
415
416
setup_header_size = 0x0202 + kernel[0x0201] - setup_hdr_offset;
+9
-10
drivers/rapidio/devices/rio_mport_cdev.c
+9
-10
drivers/rapidio/devices/rio_mport_cdev.c
···
740
740
tx->callback = dma_xfer_callback;
741
741
tx->callback_param = req;
742
742
743
-
req->dmach = chan;
744
-
req->sync = sync;
745
743
req->status = DMA_IN_PROGRESS;
746
-
init_completion(&req->req_comp);
747
744
kref_get(&req->refcount);
748
745
749
746
cookie = dmaengine_submit(tx);
···
828
831
if (!req)
829
832
return -ENOMEM;
830
833
831
-
kref_init(&req->refcount);
832
-
833
834
ret = get_dma_channel(priv);
834
835
if (ret) {
835
836
kfree(req);
836
837
return ret;
837
838
}
839
+
chan = priv->dmach;
840
+
841
+
kref_init(&req->refcount);
842
+
init_completion(&req->req_comp);
843
+
req->dir = dir;
844
+
req->filp = filp;
845
+
req->priv = priv;
846
+
req->dmach = chan;
847
+
req->sync = sync;
838
848
839
849
/*
840
850
* If parameter loc_addr != NULL, we are transferring data from/to
···
928
924
map->virt_addr + (baddr - map->phys_addr) +
929
925
xfer->offset, xfer->length);
930
926
}
931
-
932
-
req->dir = dir;
933
-
req->filp = filp;
934
-
req->priv = priv;
935
-
chan = priv->dmach;
936
927
937
928
nents = dma_map_sg(chan->device->dev,
938
929
req->sgt.sgl, req->sgt.nents, dir);
+1
-1
fs/autofs4/root.c
+1
-1
fs/autofs4/root.c
+4
-4
fs/binfmt_elf.c
+4
-4
fs/binfmt_elf.c
···
377
377
} else
378
378
map_addr = vm_mmap(filep, addr, size, prot, type, off);
379
379
380
-
if ((type & MAP_FIXED_NOREPLACE) && BAD_ADDR(map_addr))
381
-
pr_info("%d (%s): Uhuuh, elf segment at %p requested but the memory is mapped already\n",
382
-
task_pid_nr(current), current->comm,
383
-
(void *)addr);
380
+
if ((type & MAP_FIXED_NOREPLACE) &&
381
+
PTR_ERR((void *)map_addr) == -EEXIST)
382
+
pr_info("%d (%s): Uhuuh, elf segment at %px requested but the memory is mapped already\n",
383
+
task_pid_nr(current), current->comm, (void *)addr);
384
384
385
385
return(map_addr);
386
386
}
+4
-3
fs/fs-writeback.c
+4
-3
fs/fs-writeback.c
···
745
745
*/
746
746
if (inode && inode_to_wb_is_valid(inode)) {
747
747
struct bdi_writeback *wb;
748
-
bool locked, congested;
748
+
struct wb_lock_cookie lock_cookie = {};
749
+
bool congested;
749
750
750
-
wb = unlocked_inode_to_wb_begin(inode, &locked);
751
+
wb = unlocked_inode_to_wb_begin(inode, &lock_cookie);
751
752
congested = wb_congested(wb, cong_bits);
752
-
unlocked_inode_to_wb_end(inode, locked);
753
+
unlocked_inode_to_wb_end(inode, &lock_cookie);
753
754
return congested;
754
755
}
755
756
+6
fs/proc/base.c
+6
fs/proc/base.c
···
1693
1693
kuid_t uid;
1694
1694
kgid_t gid;
1695
1695
1696
+
if (unlikely(task->flags & PF_KTHREAD)) {
1697
+
*ruid = GLOBAL_ROOT_UID;
1698
+
*rgid = GLOBAL_ROOT_GID;
1699
+
return;
1700
+
}
1701
+
1696
1702
/* Default to the tasks effective ownership */
1697
1703
rcu_read_lock();
1698
1704
cred = __task_cred(task);
+1
-1
fs/proc/loadavg.c
+1
-1
fs/proc/loadavg.c
+5
-1
fs/proc/task_mmu.c
+5
-1
fs/proc/task_mmu.c
···
1310
1310
#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
1311
1311
else if (is_swap_pmd(pmd)) {
1312
1312
swp_entry_t entry = pmd_to_swp_entry(pmd);
1313
+
unsigned long offset = swp_offset(entry);
1313
1314
1315
+
offset += (addr & ~PMD_MASK) >> PAGE_SHIFT;
1314
1316
frame = swp_type(entry) |
1315
-
(swp_offset(entry) << MAX_SWAPFILES_SHIFT);
1317
+
(offset << MAX_SWAPFILES_SHIFT);
1316
1318
flags |= PM_SWAP;
1317
1319
if (pmd_swp_soft_dirty(pmd))
1318
1320
flags |= PM_SOFT_DIRTY;
···
1334
1332
break;
1335
1333
if (pm->show_pfn && (flags & PM_PRESENT))
1336
1334
frame++;
1335
+
else if (flags & PM_SWAP)
1336
+
frame += (1 << MAX_SWAPFILES_SHIFT);
1337
1337
}
1338
1338
spin_unlock(ptl);
1339
1339
return err;
+5
include/linux/backing-dev-defs.h
+5
include/linux/backing-dev-defs.h
+16
-14
include/linux/backing-dev.h
+16
-14
include/linux/backing-dev.h
···
347
347
/**
348
348
* unlocked_inode_to_wb_begin - begin unlocked inode wb access transaction
349
349
* @inode: target inode
350
-
* @lockedp: temp bool output param, to be passed to the end function
350
+
* @cookie: output param, to be passed to the end function
351
351
*
352
352
* The caller wants to access the wb associated with @inode but isn't
353
353
* holding inode->i_lock, the i_pages lock or wb->list_lock. This
···
355
355
* association doesn't change until the transaction is finished with
356
356
* unlocked_inode_to_wb_end().
357
357
*
358
-
* The caller must call unlocked_inode_to_wb_end() with *@lockdep
359
-
* afterwards and can't sleep during transaction. IRQ may or may not be
360
-
* disabled on return.
358
+
* The caller must call unlocked_inode_to_wb_end() with *@cookie afterwards and
359
+
* can't sleep during the transaction. IRQs may or may not be disabled on
360
+
* return.
361
361
*/
362
362
static inline struct bdi_writeback *
363
-
unlocked_inode_to_wb_begin(struct inode *inode, bool *lockedp)
363
+
unlocked_inode_to_wb_begin(struct inode *inode, struct wb_lock_cookie *cookie)
364
364
{
365
365
rcu_read_lock();
366
366
···
368
368
* Paired with store_release in inode_switch_wb_work_fn() and
369
369
* ensures that we see the new wb if we see cleared I_WB_SWITCH.
370
370
*/
371
-
*lockedp = smp_load_acquire(&inode->i_state) & I_WB_SWITCH;
371
+
cookie->locked = smp_load_acquire(&inode->i_state) & I_WB_SWITCH;
372
372
373
-
if (unlikely(*lockedp))
374
-
xa_lock_irq(&inode->i_mapping->i_pages);
373
+
if (unlikely(cookie->locked))
374
+
xa_lock_irqsave(&inode->i_mapping->i_pages, cookie->flags);
375
375
376
376
/*
377
377
* Protected by either !I_WB_SWITCH + rcu_read_lock() or the i_pages
···
383
383
/**
384
384
* unlocked_inode_to_wb_end - end inode wb access transaction
385
385
* @inode: target inode
386
-
* @locked: *@lockedp from unlocked_inode_to_wb_begin()
386
+
* @cookie: @cookie from unlocked_inode_to_wb_begin()
387
387
*/
388
-
static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked)
388
+
static inline void unlocked_inode_to_wb_end(struct inode *inode,
389
+
struct wb_lock_cookie *cookie)
389
390
{
390
-
if (unlikely(locked))
391
-
xa_unlock_irq(&inode->i_mapping->i_pages);
391
+
if (unlikely(cookie->locked))
392
+
xa_unlock_irqrestore(&inode->i_mapping->i_pages, cookie->flags);
392
393
393
394
rcu_read_unlock();
394
395
}
···
436
435
}
437
436
438
437
static inline struct bdi_writeback *
439
-
unlocked_inode_to_wb_begin(struct inode *inode, bool *lockedp)
438
+
unlocked_inode_to_wb_begin(struct inode *inode, struct wb_lock_cookie *cookie)
440
439
{
441
440
return inode_to_wb(inode);
442
441
}
443
442
444
-
static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked)
443
+
static inline void unlocked_inode_to_wb_end(struct inode *inode,
444
+
struct wb_lock_cookie *cookie)
445
445
{
446
446
}
447
447
+3
include/linux/compiler-clang.h
+3
include/linux/compiler-clang.h
+1
-5
include/linux/thread_info.h
+1
-5
include/linux/thread_info.h
···
43
43
#define THREAD_ALIGN THREAD_SIZE
44
44
#endif
45
45
46
-
#if IS_ENABLED(CONFIG_DEBUG_STACK_USAGE) || IS_ENABLED(CONFIG_DEBUG_KMEMLEAK)
47
-
# define THREADINFO_GFP (GFP_KERNEL_ACCOUNT | __GFP_ZERO)
48
-
#else
49
-
# define THREADINFO_GFP (GFP_KERNEL_ACCOUNT)
50
-
#endif
46
+
#define THREADINFO_GFP (GFP_KERNEL_ACCOUNT | __GFP_ZERO)
51
47
52
48
/*
53
49
* flag set/clear/test wrappers
+1
-2
kernel/fork.c
+1
-2
kernel/fork.c
+4
-5
mm/filemap.c
+4
-5
mm/filemap.c
···
786
786
VM_BUG_ON_PAGE(!PageLocked(new), new);
787
787
VM_BUG_ON_PAGE(new->mapping, new);
788
788
789
-
error = radix_tree_preload(gfp_mask & ~__GFP_HIGHMEM);
789
+
error = radix_tree_preload(gfp_mask & GFP_RECLAIM_MASK);
790
790
if (!error) {
791
791
struct address_space *mapping = old->mapping;
792
792
void (*freepage)(struct page *);
···
842
842
return error;
843
843
}
844
844
845
-
error = radix_tree_maybe_preload(gfp_mask & ~__GFP_HIGHMEM);
845
+
error = radix_tree_maybe_preload(gfp_mask & GFP_RECLAIM_MASK);
846
846
if (error) {
847
847
if (!huge)
848
848
mem_cgroup_cancel_charge(page, memcg, false);
···
1585
1585
if (fgp_flags & FGP_ACCESSED)
1586
1586
__SetPageReferenced(page);
1587
1587
1588
-
err = add_to_page_cache_lru(page, mapping, offset,
1589
-
gfp_mask & GFP_RECLAIM_MASK);
1588
+
err = add_to_page_cache_lru(page, mapping, offset, gfp_mask);
1590
1589
if (unlikely(err)) {
1591
1590
put_page(page);
1592
1591
page = NULL;
···
2386
2387
if (!page)
2387
2388
return -ENOMEM;
2388
2389
2389
-
ret = add_to_page_cache_lru(page, mapping, offset, gfp_mask & GFP_KERNEL);
2390
+
ret = add_to_page_cache_lru(page, mapping, offset, gfp_mask);
2390
2391
if (ret == 0)
2391
2392
ret = mapping->a_ops->readpage(file, page);
2392
2393
else if (ret == -EEXIST)
+4
-1
mm/huge_memory.c
+4
-1
mm/huge_memory.c
···
2925
2925
pmde = maybe_pmd_mkwrite(pmde, vma);
2926
2926
2927
2927
flush_cache_range(vma, mmun_start, mmun_start + HPAGE_PMD_SIZE);
2928
-
page_add_anon_rmap(new, vma, mmun_start, true);
2928
+
if (PageAnon(new))
2929
+
page_add_anon_rmap(new, vma, mmun_start, true);
2930
+
else
2931
+
page_add_file_rmap(new, true);
2929
2932
set_pmd_at(mm, mmun_start, pvmw->pmd, pmde);
2930
2933
if (vma->vm_flags & VM_LOCKED)
2931
2934
mlock_vma_page(new);
+1
-1
mm/memcontrol.c
+1
-1
mm/memcontrol.c
+19
-3
mm/migrate.c
+19
-3
mm/migrate.c
···
472
472
pslot = radix_tree_lookup_slot(&mapping->i_pages,
473
473
page_index(page));
474
474
475
-
expected_count += 1 + page_has_private(page);
475
+
expected_count += hpage_nr_pages(page) + page_has_private(page);
476
476
if (page_count(page) != expected_count ||
477
477
radix_tree_deref_slot_protected(pslot,
478
478
&mapping->i_pages.xa_lock) != page) {
···
505
505
*/
506
506
newpage->index = page->index;
507
507
newpage->mapping = page->mapping;
508
-
get_page(newpage); /* add cache reference */
508
+
page_ref_add(newpage, hpage_nr_pages(page)); /* add cache reference */
509
509
if (PageSwapBacked(page)) {
510
510
__SetPageSwapBacked(newpage);
511
511
if (PageSwapCache(page)) {
···
524
524
}
525
525
526
526
radix_tree_replace_slot(&mapping->i_pages, pslot, newpage);
527
+
if (PageTransHuge(page)) {
528
+
int i;
529
+
int index = page_index(page);
530
+
531
+
for (i = 0; i < HPAGE_PMD_NR; i++) {
532
+
pslot = radix_tree_lookup_slot(&mapping->i_pages,
533
+
index + i);
534
+
radix_tree_replace_slot(&mapping->i_pages, pslot,
535
+
newpage + i);
536
+
}
537
+
} else {
538
+
radix_tree_replace_slot(&mapping->i_pages, pslot, newpage);
539
+
}
527
540
528
541
/*
529
542
* Drop cache reference from old page by unfreezing
530
543
* to one less reference.
531
544
* We know this isn't the last reference.
532
545
*/
533
-
page_ref_unfreeze(page, expected_count - 1);
546
+
page_ref_unfreeze(page, expected_count - hpage_nr_pages(page));
534
547
535
548
xa_unlock(&mapping->i_pages);
536
549
/* Leave irq disabled to prevent preemption while updating stats */
···
1635
1622
current_node = NUMA_NO_NODE;
1636
1623
}
1637
1624
out_flush:
1625
+
if (list_empty(&pagelist))
1626
+
return err;
1627
+
1638
1628
/* Make sure we do not overwrite the existing error */
1639
1629
err1 = do_move_pages_to_node(mm, &pagelist, current_node);
1640
1630
if (!err1)
+9
-9
mm/page-writeback.c
+9
-9
mm/page-writeback.c
···
2502
2502
if (mapping && mapping_cap_account_dirty(mapping)) {
2503
2503
struct inode *inode = mapping->host;
2504
2504
struct bdi_writeback *wb;
2505
-
bool locked;
2505
+
struct wb_lock_cookie cookie = {};
2506
2506
2507
-
wb = unlocked_inode_to_wb_begin(inode, &locked);
2507
+
wb = unlocked_inode_to_wb_begin(inode, &cookie);
2508
2508
current->nr_dirtied--;
2509
2509
dec_node_page_state(page, NR_DIRTIED);
2510
2510
dec_wb_stat(wb, WB_DIRTIED);
2511
-
unlocked_inode_to_wb_end(inode, locked);
2511
+
unlocked_inode_to_wb_end(inode, &cookie);
2512
2512
}
2513
2513
}
2514
2514
EXPORT_SYMBOL(account_page_redirty);
···
2614
2614
if (mapping_cap_account_dirty(mapping)) {
2615
2615
struct inode *inode = mapping->host;
2616
2616
struct bdi_writeback *wb;
2617
-
bool locked;
2617
+
struct wb_lock_cookie cookie = {};
2618
2618
2619
2619
lock_page_memcg(page);
2620
-
wb = unlocked_inode_to_wb_begin(inode, &locked);
2620
+
wb = unlocked_inode_to_wb_begin(inode, &cookie);
2621
2621
2622
2622
if (TestClearPageDirty(page))
2623
2623
account_page_cleaned(page, mapping, wb);
2624
2624
2625
-
unlocked_inode_to_wb_end(inode, locked);
2625
+
unlocked_inode_to_wb_end(inode, &cookie);
2626
2626
unlock_page_memcg(page);
2627
2627
} else {
2628
2628
ClearPageDirty(page);
···
2654
2654
if (mapping && mapping_cap_account_dirty(mapping)) {
2655
2655
struct inode *inode = mapping->host;
2656
2656
struct bdi_writeback *wb;
2657
-
bool locked;
2657
+
struct wb_lock_cookie cookie = {};
2658
2658
2659
2659
/*
2660
2660
* Yes, Virginia, this is indeed insane.
···
2691
2691
* always locked coming in here, so we get the desired
2692
2692
* exclusion.
2693
2693
*/
2694
-
wb = unlocked_inode_to_wb_begin(inode, &locked);
2694
+
wb = unlocked_inode_to_wb_begin(inode, &cookie);
2695
2695
if (TestClearPageDirty(page)) {
2696
2696
dec_lruvec_page_state(page, NR_FILE_DIRTY);
2697
2697
dec_zone_page_state(page, NR_ZONE_WRITE_PENDING);
2698
2698
dec_wb_stat(wb, WB_RECLAIMABLE);
2699
2699
ret = 1;
2700
2700
}
2701
-
unlocked_inode_to_wb_end(inode, locked);
2701
+
unlocked_inode_to_wb_end(inode, &cookie);
2702
2702
return ret;
2703
2703
}
2704
2704
return TestClearPageDirty(page);