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

Merge branch 'akpm' (patches from Andrew) 

Merge misc fixes from Andrew Morton:
 "14 fixes and one selftest to verify the ipc fixes herein"

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
  mm: limit boost_watermark on small zones
  ubsan: disable UBSAN_ALIGNMENT under COMPILE_TEST
  mm/vmscan: remove unnecessary argument description of isolate_lru_pages()
  epoll: atomically remove wait entry on wake up
  kselftests: introduce new epoll60 testcase for catching lost wakeups
  percpu: make pcpu_alloc() aware of current gfp context
  mm/slub: fix incorrect interpretation of s->offset
  scripts/gdb: repair rb_first() and rb_last()
  eventpoll: fix missing wakeup for ovflist in ep_poll_callback
  arch/x86/kvm/svm/sev.c: change flag passed to GUP fast in sev_pin_memory()
  scripts/decodecode: fix trapping instruction formatting
  kernel/kcov.c: fix typos in kcov_remote_start documentation
  mm/page_alloc: fix watchdog soft lockups during set_zone_contiguous()
  mm, memcg: fix error return value of mem_cgroup_css_alloc()
  ipc/mqueue.c: change __do_notify() to bypass check_kill_permission()
parents 79dede78 14f69140

arch/x86/kvm/svm/sev.c

+1 −1
Original line number Diff line number Diff line
@@ -345,7 +345,7 @@ static struct page **sev_pin_memory(struct kvm *kvm, unsigned long uaddr, 
		return NULL;



	/* Pin the user virtual address. */

	npinned = get_user_pages_fast(uaddr, npages, FOLL_WRITE, pages);

	npinned = get_user_pages_fast(uaddr, npages, write ? FOLL_WRITE : 0, pages);

	if (npinned != npages) {

		pr_err("SEV: Failure locking %lu pages.\n", npages);

		goto err;

fs/eventpoll.c

+33 −28
Original line number Diff line number Diff line
@@ -1171,6 +1171,10 @@ static inline bool chain_epi_lockless(struct epitem *epi) 
{

	struct eventpoll *ep = epi->ep;



	/* Fast preliminary check */

	if (epi->next != EP_UNACTIVE_PTR)

		return false;



	/* Check that the same epi has not been just chained from another CPU */

	if (cmpxchg(&epi->next, EP_UNACTIVE_PTR, NULL) != EP_UNACTIVE_PTR)

		return false;
@@ -1237,15 +1241,11 @@ static int ep_poll_callback(wait_queue_entry_t *wait, unsigned mode, int sync, v 
	 * chained in ep->ovflist and requeued later on.

	 */

	if (READ_ONCE(ep->ovflist) != EP_UNACTIVE_PTR) {

		if (epi->next == EP_UNACTIVE_PTR &&

		    chain_epi_lockless(epi))

		if (chain_epi_lockless(epi))

			ep_pm_stay_awake_rcu(epi);

		goto out_unlock;

	}



	/* If this file is already in the ready list we exit soon */

	if (!ep_is_linked(epi) &&

	    list_add_tail_lockless(&epi->rdllink, &ep->rdllist)) {

	} else if (!ep_is_linked(epi)) {

		/* In the usual case, add event to ready list. */

		if (list_add_tail_lockless(&epi->rdllink, &ep->rdllist))

			ep_pm_stay_awake_rcu(epi);

	}
@@ -1822,7 +1822,6 @@ static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events, 
{

	int res = 0, eavail, timed_out = 0;

	u64 slack = 0;

	bool waiter = false;

	wait_queue_entry_t wait;

	ktime_t expires, *to = NULL;
@@ -1867,21 +1866,23 @@ fetch_events: 
	 */

	ep_reset_busy_poll_napi_id(ep);



	do {

		/*

	 * We don't have any available event to return to the caller.  We need

	 * to sleep here, and we will be woken by ep_poll_callback() when events

	 * become available.

		 * Internally init_wait() uses autoremove_wake_function(),

		 * thus wait entry is removed from the wait queue on each

		 * wakeup. Why it is important? In case of several waiters

		 * each new wakeup will hit the next waiter, giving it the

		 * chance to harvest new event. Otherwise wakeup can be

		 * lost. This is also good performance-wise, because on

		 * normal wakeup path no need to call __remove_wait_queue()

		 * explicitly, thus ep->lock is not taken, which halts the

		 * event delivery.

		 */

	if (!waiter) {

		waiter = true;

		init_waitqueue_entry(&wait, current);



		init_wait(&wait);

		write_lock_irq(&ep->lock);

		__add_wait_queue_exclusive(&ep->wq, &wait);

		write_unlock_irq(&ep->lock);

	}



	for (;;) {

		/*

		 * We don't want to sleep if the ep_poll_callback() sends us

		 * a wakeup in between. That's why we set the task state
@@ -1911,10 +1912,20 @@ fetch_events: 
			timed_out = 1;

			break;

		}

	}



		/* We were woken up, thus go and try to harvest some events */

		eavail = 1;



	} while (0);



	__set_current_state(TASK_RUNNING);



	if (!list_empty_careful(&wait.entry)) {

		write_lock_irq(&ep->lock);

		__remove_wait_queue(&ep->wq, &wait);

		write_unlock_irq(&ep->lock);

	}



send_events:

	/*

	 * Try to transfer events to user space. In case we get 0 events and
@@ -1925,12 +1936,6 @@ send_events: 
	    !(res = ep_send_events(ep, events, maxevents)) && !timed_out)

		goto fetch_events;



	if (waiter) {

		write_lock_irq(&ep->lock);

		__remove_wait_queue(&ep->wq, &wait);

		write_unlock_irq(&ep->lock);

	}



	return res;

}

ipc/mqueue.c

+26 −8
Original line number Diff line number Diff line
@@ -142,6 +142,7 @@ struct mqueue_inode_info { 


	struct sigevent notify;

	struct pid *notify_owner;

	u32 notify_self_exec_id;

	struct user_namespace *notify_user_ns;

	struct user_struct *user;	/* user who created, for accounting */

	struct sock *notify_sock;
@@ -773,28 +774,44 @@ static void __do_notify(struct mqueue_inode_info *info) 
	 * synchronously. */

	if (info->notify_owner &&

	    info->attr.mq_curmsgs == 1) {

		struct kernel_siginfo sig_i;

		switch (info->notify.sigev_notify) {

		case SIGEV_NONE:

			break;

		case SIGEV_SIGNAL:

			/* sends signal */

		case SIGEV_SIGNAL: {

			struct kernel_siginfo sig_i;

			struct task_struct *task;



			/* do_mq_notify() accepts sigev_signo == 0, why?? */

			if (!info->notify.sigev_signo)

				break;



			clear_siginfo(&sig_i);

			sig_i.si_signo = info->notify.sigev_signo;

			sig_i.si_errno = 0;

			sig_i.si_code = SI_MESGQ;

			sig_i.si_value = info->notify.sigev_value;

			/* map current pid/uid into info->owner's namespaces */

			rcu_read_lock();

			/* map current pid/uid into info->owner's namespaces */

			sig_i.si_pid = task_tgid_nr_ns(current,

						ns_of_pid(info->notify_owner));

			sig_i.si_uid = from_kuid_munged(info->notify_user_ns, current_uid());

			sig_i.si_uid = from_kuid_munged(info->notify_user_ns,

						current_uid());

			/*

			 * We can't use kill_pid_info(), this signal should

			 * bypass check_kill_permission(). It is from kernel

			 * but si_fromuser() can't know this.

			 * We do check the self_exec_id, to avoid sending

			 * signals to programs that don't expect them.

			 */

			task = pid_task(info->notify_owner, PIDTYPE_TGID);

			if (task && task->self_exec_id ==

						info->notify_self_exec_id) {

				do_send_sig_info(info->notify.sigev_signo,

						&sig_i, task, PIDTYPE_TGID);

			}

			rcu_read_unlock();



			kill_pid_info(info->notify.sigev_signo,

				      &sig_i, info->notify_owner);

			break;

		}

		case SIGEV_THREAD:

			set_cookie(info->notify_cookie, NOTIFY_WOKENUP);

			netlink_sendskb(info->notify_sock, info->notify_cookie);
@@ -1383,6 +1400,7 @@ retry: 
			info->notify.sigev_signo = notification->sigev_signo;

			info->notify.sigev_value = notification->sigev_value;

			info->notify.sigev_notify = SIGEV_SIGNAL;

			info->notify_self_exec_id = current->self_exec_id;

			break;

		}

kernel/kcov.c

+2 −2
Original line number Diff line number Diff line
@@ -740,8 +740,8 @@ static const struct file_operations kcov_fops = { 
 * kcov_remote_handle() with KCOV_SUBSYSTEM_COMMON as the subsystem id and an

 * arbitrary 4-byte non-zero number as the instance id). This common handle

 * then gets saved into the task_struct of the process that issued the

 * KCOV_REMOTE_ENABLE ioctl. When this proccess issues system calls that spawn

 * kernel threads, the common handle must be retrived via kcov_common_handle()

 * KCOV_REMOTE_ENABLE ioctl. When this process issues system calls that spawn

 * kernel threads, the common handle must be retrieved via kcov_common_handle()

 * and passed to the spawned threads via custom annotations. Those kernel

 * threads must in turn be annotated with kcov_remote_start(common_handle) and

 * kcov_remote_stop(). All of the threads that are spawned by the same process

lib/Kconfig.ubsan

+6 −9
Original line number Diff line number Diff line
@@ -60,18 +60,15 @@ config UBSAN_SANITIZE_ALL 
	  Enabling this option will get kernel image size increased

	  significantly.



config UBSAN_NO_ALIGNMENT

	bool "Disable checking of pointers alignment"

	default y if HAVE_EFFICIENT_UNALIGNED_ACCESS

config UBSAN_ALIGNMENT

	bool "Enable checks for pointers alignment"

	default !HAVE_EFFICIENT_UNALIGNED_ACCESS

	depends on !X86 || !COMPILE_TEST

	help

	  This option disables the check of unaligned memory accesses.

	  This option should be used when building allmodconfig.

	  Disabling this option on architectures that support unaligned

	  This option enables the check of unaligned memory accesses.

	  Enabling this option on architectures that support unaligned

	  accesses may produce a lot of false positives.



config UBSAN_ALIGNMENT

	def_bool !UBSAN_NO_ALIGNMENT



config TEST_UBSAN

	tristate "Module for testing for undefined behavior detection"

	depends on m

CRA Git | Maintained and supported by SUSTech CRA and CCSE