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

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

Merge branch 'core-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull core kernel fixes from Ingo Molnar:
 "This is mostly the copy_to_user_mcsafe() related fixes from Dan
  Williams, and an ORC fix for Clang"

* 'core-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  x86/asm/memcpy_mcsafe: Fix copy_to_user_mcsafe() exception handling
  lib/iov_iter: Fix pipe handling in _copy_to_iter_mcsafe()
  lib/iov_iter: Document _copy_to_iter_flushcache()
  lib/iov_iter: Document _copy_to_iter_mcsafe()
  objtool: Use '.strtab' if '.shstrtab' doesn't exist, to support ORC tables on Clang
parents ffb48e79 092b31aa

arch/x86/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -63,7 +63,7 @@ config X86 
	select ARCH_HAS_PTE_SPECIAL

	select ARCH_HAS_REFCOUNT

	select ARCH_HAS_UACCESS_FLUSHCACHE	if X86_64

	select ARCH_HAS_UACCESS_MCSAFE		if X86_64

	select ARCH_HAS_UACCESS_MCSAFE		if X86_64 && X86_MCE

	select ARCH_HAS_SET_MEMORY

	select ARCH_HAS_SG_CHAIN

	select ARCH_HAS_STRICT_KERNEL_RWX

arch/x86/include/asm/uaccess_64.h

+6 −1
Original line number Diff line number Diff line
@@ -52,7 +52,12 @@ copy_to_user_mcsafe(void *to, const void *from, unsigned len) 
	unsigned long ret;



	__uaccess_begin();

	ret = memcpy_mcsafe(to, from, len);

	/*

	 * Note, __memcpy_mcsafe() is explicitly used since it can

	 * handle exceptions / faults.  memcpy_mcsafe() may fall back to

	 * memcpy() which lacks this handling.

	 */

	ret = __memcpy_mcsafe(to, from, len);

	__uaccess_end();

	return ret;

}

lib/iov_iter.c

+73 −4
Original line number Diff line number Diff line
@@ -596,15 +596,70 @@ static unsigned long memcpy_mcsafe_to_page(struct page *page, size_t offset, 
	return ret;

}



static size_t copy_pipe_to_iter_mcsafe(const void *addr, size_t bytes,

				struct iov_iter *i)

{

	struct pipe_inode_info *pipe = i->pipe;

	size_t n, off, xfer = 0;

	int idx;



	if (!sanity(i))

		return 0;



	bytes = n = push_pipe(i, bytes, &idx, &off);

	if (unlikely(!n))

		return 0;

	for ( ; n; idx = next_idx(idx, pipe), off = 0) {

		size_t chunk = min_t(size_t, n, PAGE_SIZE - off);

		unsigned long rem;



		rem = memcpy_mcsafe_to_page(pipe->bufs[idx].page, off, addr,

				chunk);

		i->idx = idx;

		i->iov_offset = off + chunk - rem;

		xfer += chunk - rem;

		if (rem)

			break;

		n -= chunk;

		addr += chunk;

	}

	i->count -= xfer;

	return xfer;

}



/**

 * _copy_to_iter_mcsafe - copy to user with source-read error exception handling

 * @addr: source kernel address

 * @bytes: total transfer length

 * @iter: destination iterator

 *

 * The pmem driver arranges for filesystem-dax to use this facility via

 * dax_copy_to_iter() for protecting read/write to persistent memory.

 * Unless / until an architecture can guarantee identical performance

 * between _copy_to_iter_mcsafe() and _copy_to_iter() it would be a

 * performance regression to switch more users to the mcsafe version.

 *

 * Otherwise, the main differences between this and typical _copy_to_iter().

 *

 * * Typical tail/residue handling after a fault retries the copy

 *   byte-by-byte until the fault happens again. Re-triggering machine

 *   checks is potentially fatal so the implementation uses source

 *   alignment and poison alignment assumptions to avoid re-triggering

 *   hardware exceptions.

 *

 * * ITER_KVEC, ITER_PIPE, and ITER_BVEC can return short copies.

 *   Compare to copy_to_iter() where only ITER_IOVEC attempts might return

 *   a short copy.

 *

 * See MCSAFE_TEST for self-test.

 */

size_t _copy_to_iter_mcsafe(const void *addr, size_t bytes, struct iov_iter *i)

{

	const char *from = addr;

	unsigned long rem, curr_addr, s_addr = (unsigned long) addr;



	if (unlikely(i->type & ITER_PIPE)) {

		WARN_ON(1);

		return 0;

	}

	if (unlikely(i->type & ITER_PIPE))

		return copy_pipe_to_iter_mcsafe(addr, bytes, i);

	if (iter_is_iovec(i))

		might_fault();

	iterate_and_advance(i, bytes, v,
@@ -701,6 +756,20 @@ size_t _copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i) 
EXPORT_SYMBOL(_copy_from_iter_nocache);



#ifdef CONFIG_ARCH_HAS_UACCESS_FLUSHCACHE

/**

 * _copy_from_iter_flushcache - write destination through cpu cache

 * @addr: destination kernel address

 * @bytes: total transfer length

 * @iter: source iterator

 *

 * The pmem driver arranges for filesystem-dax to use this facility via

 * dax_copy_from_iter() for ensuring that writes to persistent memory

 * are flushed through the CPU cache. It is differentiated from

 * _copy_from_iter_nocache() in that guarantees all data is flushed for

 * all iterator types. The _copy_from_iter_nocache() only attempts to

 * bypass the cache for the ITER_IOVEC case, and on some archs may use

 * instructions that strand dirty-data in the cache.

 */

size_t _copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i)

{

	char *to = addr;

tools/objtool/elf.c

+4 −2
Original line number Diff line number Diff line
@@ -519,10 +519,12 @@ struct section *elf_create_section(struct elf *elf, const char *name, 
	sec->sh.sh_flags = SHF_ALLOC;





	/* Add section name to .shstrtab */

	/* Add section name to .shstrtab (or .strtab for Clang) */

	shstrtab = find_section_by_name(elf, ".shstrtab");

	if (!shstrtab)

		shstrtab = find_section_by_name(elf, ".strtab");

	if (!shstrtab) {

		WARN("can't find .shstrtab section");

		WARN("can't find .shstrtab or .strtab section");

		return NULL;

	}