Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit eda57a0e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'akpm' (patches from Andrew) 

Merge misc fixes from Andrew Morton:
 "The usual shower of hotfixes.

  Chris's memcg patches aren't actually fixes - they're mature but a few
  niggling review issues were late to arrive.

  The ocfs2 fixes are quite old - those took some time to get reviewer
  attention.

  Subsystems affected by this patch series: ocfs2, hotfixes, mm/memcg,
  mm/slab-generic"

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
  mm, sl[aou]b: guarantee natural alignment for kmalloc(power-of-two)
  mm, sl[ou]b: improve memory accounting
  mm, memcg: make scan aggression always exclude protection
  mm, memcg: make memory.emin the baseline for utilisation determination
  mm, memcg: proportional memory.{low,min} reclaim
  mm/vmpressure.c: fix a signedness bug in vmpressure_register_event()
  mm/page_alloc.c: fix a crash in free_pages_prepare()
  mm/z3fold.c: claim page in the beginning of free
  kernel/sysctl.c: do not override max_threads provided by userspace
  memcg: only record foreign writebacks with dirty pages when memcg is not disabled
  mm: fix -Wmissing-prototypes warnings
  writeback: fix use-after-free in finish_writeback_work()
  mm/memremap: drop unused SECTION_SIZE and SECTION_MASK
  panic: ensure preemption is disabled during panic()
  fs: ocfs2: fix a possible null-pointer dereference in ocfs2_info_scan_inode_alloc()
  fs: ocfs2: fix a possible null-pointer dereference in ocfs2_write_end_nolock()
  fs: ocfs2: fix possible null-pointer dereferences in ocfs2_xa_prepare_entry()
  ocfs2: clear zero in unaligned direct IO
parents c512c691 59bb4798

Documentation/admin-guide/cgroup-v2.rst

+14 −6
Original line number Diff line number Diff line
@@ -615,8 +615,8 @@ on an IO device and is an example of this type. 
Protections

-----------



A cgroup is protected to be allocated upto the configured amount of

the resource if the usages of all its ancestors are under their

A cgroup is protected upto the configured amount of the resource

as long as the usages of all its ancestors are under their

protected levels.  Protections can be hard guarantees or best effort

soft boundaries.  Protections can also be over-committed in which case

only upto the amount available to the parent is protected among
@@ -1096,7 +1096,10 @@ PAGE_SIZE multiple when read back. 
	is within its effective min boundary, the cgroup's memory

	won't be reclaimed under any conditions. If there is no

	unprotected reclaimable memory available, OOM killer

	is invoked.

	is invoked. Above the effective min boundary (or

	effective low boundary if it is higher), pages are reclaimed

	proportionally to the overage, reducing reclaim pressure for

	smaller overages.



       Effective min boundary is limited by memory.min values of

	all ancestor cgroups. If there is memory.min overcommitment
@@ -1118,7 +1121,10 @@ PAGE_SIZE multiple when read back. 
	Best-effort memory protection.  If the memory usage of a

	cgroup is within its effective low boundary, the cgroup's

	memory won't be reclaimed unless memory can be reclaimed

	from unprotected cgroups.

	from unprotected cgroups.  Above the effective low boundary (or

	effective min boundary if it is higher), pages are reclaimed

	proportionally to the overage, reducing reclaim pressure for

	smaller overages.



	Effective low boundary is limited by memory.low values of

	all ancestor cgroups. If there is memory.low overcommitment
@@ -2482,8 +2488,10 @@ system performance due to overreclaim, to the point where the feature 
becomes self-defeating.



The memory.low boundary on the other hand is a top-down allocated

reserve.  A cgroup enjoys reclaim protection when it's within its low,

which makes delegation of subtrees possible.

reserve.  A cgroup enjoys reclaim protection when it's within its

effective low, which makes delegation of subtrees possible. It also

enjoys having reclaim pressure proportional to its overage when

above its effective low.



The original high boundary, the hard limit, is defined as a strict

limit that can not budge, even if the OOM killer has to be called.

Documentation/core-api/memory-allocation.rst

+4 −0
Original line number Diff line number Diff line
@@ -98,6 +98,10 @@ limited. The actual limit depends on the hardware and the kernel 
configuration, but it is a good practice to use `kmalloc` for objects

smaller than page size.



The address of a chunk allocated with `kmalloc` is aligned to at least

ARCH_KMALLOC_MINALIGN bytes.  For sizes which are a power of two, the

alignment is also guaranteed to be at least the respective size.



For large allocations you can use :c:func:`vmalloc` and

:c:func:`vzalloc`, or directly request pages from the page

allocator. The memory allocated by `vmalloc` and related functions is

fs/fs-writeback.c

+7 −2
Original line number Diff line number Diff line
@@ -164,8 +164,13 @@ static void finish_writeback_work(struct bdi_writeback *wb, 


	if (work->auto_free)

		kfree(work);

	if (done && atomic_dec_and_test(&done->cnt))

		wake_up_all(done->waitq);

	if (done) {

		wait_queue_head_t *waitq = done->waitq;



		/* @done can't be accessed after the following dec */

		if (atomic_dec_and_test(&done->cnt))

			wake_up_all(waitq);

	}

}



static void wb_queue_work(struct bdi_writeback *wb,

fs/ocfs2/aops.c

+23 −2
Original line number Diff line number Diff line
@@ -2049,6 +2049,7 @@ int ocfs2_write_end_nolock(struct address_space *mapping, 
		inode->i_mtime = inode->i_ctime = current_time(inode);

		di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);

		di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);

		if (handle)

			ocfs2_update_inode_fsync_trans(handle, inode, 1);

	}

	if (handle)
@@ -2146,13 +2147,30 @@ static int ocfs2_dio_wr_get_block(struct inode *inode, sector_t iblock, 
	struct ocfs2_dio_write_ctxt *dwc = NULL;

	struct buffer_head *di_bh = NULL;

	u64 p_blkno;

	loff_t pos = iblock << inode->i_sb->s_blocksize_bits;

	unsigned int i_blkbits = inode->i_sb->s_blocksize_bits;

	loff_t pos = iblock << i_blkbits;

	sector_t endblk = (i_size_read(inode) - 1) >> i_blkbits;

	unsigned len, total_len = bh_result->b_size;

	int ret = 0, first_get_block = 0;



	len = osb->s_clustersize - (pos & (osb->s_clustersize - 1));

	len = min(total_len, len);



	/*

	 * bh_result->b_size is count in get_more_blocks according to write

	 * "pos" and "end", we need map twice to return different buffer state:

	 * 1. area in file size, not set NEW;

	 * 2. area out file size, set  NEW.

	 *

	 *		   iblock    endblk

	 * |--------|---------|---------|---------

	 * |<-------area in file------->|

	 */



	if ((iblock <= endblk) &&

	    ((iblock + ((len - 1) >> i_blkbits)) > endblk))

		len = (endblk - iblock + 1) << i_blkbits;



	mlog(0, "get block of %lu at %llu:%u req %u\n",

			inode->i_ino, pos, len, total_len);
@@ -2236,6 +2254,9 @@ static int ocfs2_dio_wr_get_block(struct inode *inode, sector_t iblock, 
	if (desc->c_needs_zero)

		set_buffer_new(bh_result);



	if (iblock > endblk)

		set_buffer_new(bh_result);



	/* May sleep in end_io. It should not happen in a irq context. So defer

	 * it to dio work queue. */

	set_buffer_defer_completion(bh_result);

fs/ocfs2/ioctl.c

+1 −1
Original line number Diff line number Diff line
@@ -283,7 +283,7 @@ static int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb, 
	if (inode_alloc)

		inode_lock(inode_alloc);



	if (o2info_coherent(&fi->ifi_req)) {

	if (inode_alloc && o2info_coherent(&fi->ifi_req)) {

		status = ocfs2_inode_lock(inode_alloc, &bh, 0);

		if (status < 0) {

			mlog_errno(status);