Skip to contentSkip to conversation

android: binder: Disable preemption while holding the global binder lock

PATCH In review Todd Kjos 3 participants 6 messages Sep 9, 2016 – Sep 10, 2016

Subsystems (2)
lore
Share & tools
lore

Todd Kjos

author maintainer
#0 lore raw

PATCH 1/1 android: binder: Disable preemption while holding the global binder lock

From: Todd Kjos <[email protected]>

In Android systems, the display pipeline relies on low latency binder transactions and is therefore sensitive to delays caused by contention for the global binder lock. Jank is significantly reduced by disabling preemption while the global binder lock is held.

This patch was originated by Riley Andrews <[email protected]> with tweaks and forward-porting by me.

Originally-from: Riley Andrews <[email protected]>

---
 drivers/android/binder.c | 194 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 146 insertions(+), 48 deletions(-)
drivers/android/binder.c +146 -48
index 16288e7..c36e420 100644
@@ -379,6 +379,7 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 	struct files_struct *files = proc->files;
 	unsigned long rlim_cur;
 	unsigned long irqs;
+	int ret;
 
 	if (files == NULL)
 		return -ESRCH;
@@ -389,7 +390,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 	rlim_cur = task_rlimit(proc->tsk, RLIMIT_NOFILE);
 	unlock_task_sighand(proc->tsk, &irqs);
 
-	return __alloc_fd(files, 0, rlim_cur, flags);
+	preempt_enable_no_resched();
+	ret = __alloc_fd(files, 0, rlim_cur, flags);
+	preempt_disable();
+
+	return ret;
 }
 
 /*
@@ -398,8 +403,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 static void task_fd_install(
 	struct binder_proc *proc, unsigned int fd, struct file *file)
 {
-	if (proc->files)
+	if (proc->files) {
+		preempt_enable_no_resched();
 		__fd_install(proc->files, fd, file);
+		preempt_disable();
+	}
 }
 
 /*
@@ -427,6 +435,7 @@ static inline void binder_lock(const char *tag)
 {
 	trace_binder_lock(tag);
 	mutex_lock(&binder_main_lock);
+	preempt_disable();
 	trace_binder_locked(tag);
 }
 
@@ -434,8 +443,65 @@ static inline void binder_unlock(const char *tag)
 {
 	trace_binder_unlock(tag);
 	mutex_unlock(&binder_main_lock);
+	preempt_enable();
+}
+
+static inline void *kzalloc_nopreempt(size_t size)
+{
+	void *ptr;
+
+	ptr = kzalloc(size, GFP_NOWAIT);
+	if (ptr)
+		return ptr;
+
+	preempt_enable_no_resched();
+	ptr = kzalloc(size, GFP_KERNEL);
+	preempt_disable();
+
+	return ptr;
+}
+
+static inline long copy_to_user_nopreempt(void __user *to,
+					  const void *from, long n)
+{
+	long ret;
+
+	preempt_enable_no_resched();
+	ret = copy_to_user(to, from, n);
+	preempt_disable();
+	return ret;
+}
+
+static inline long copy_from_user_nopreempt(void *to,
+					    const void __user *from,
+					    long n)
+{
+	long ret;
+
+	preempt_enable_no_resched();
+	ret = copy_from_user(to, from, n);
+	preempt_disable();
+	return ret;
 }
 
+#define get_user_nopreempt(x, ptr)	\
+({						\
+	int __ret;				\
+	preempt_enable_no_resched();		\
+	__ret = get_user(x, ptr);		\
+	preempt_disable();			\
+	__ret;					\
+})
+
+#define put_user_nopreempt(x, ptr)	\
+({						\
+	int __ret;				\
+	preempt_enable_no_resched();		\
+	__ret = put_user(x, ptr);		\
+	preempt_disable();			\
+	__ret;					\
+})
+
 static void binder_set_nice(long nice)
 {
 	long min_nice;
@@ -568,6 +634,8 @@ static int binder_update_page_range(struct binder_proc *proc, int allocate,
 	else
 		mm = get_task_mm(proc->tsk);
 
+	preempt_enable_no_resched();
+
 	if (mm) {
 		down_write(&mm->mmap_sem);
 		vma = proc->vma;
@@ -622,6 +690,9 @@ static int binder_update_page_range(struct binder_proc *proc, int allocate,
 		up_write(&mm->mmap_sem);
 		mmput(mm);
 	}
+
+	preempt_disable();
+
 	return 0;
 
 free_range:
@@ -644,6 +715,9 @@ err_no_vma:
 		up_write(&mm->mmap_sem);
 		mmput(mm);
 	}
+
+	preempt_disable();
+
 	return -ENOMEM;
 }
 
@@ -903,7 +977,7 @@ static struct binder_node *binder_new_node(struct binder_proc *proc,
 			return NULL;
 	}
 
-	node = kzalloc(sizeof(*node), GFP_KERNEL);
+	node = kzalloc_nopreempt(sizeof(*node));
 	if (node == NULL)
 		return NULL;
 	binder_stats_created(BINDER_STAT_NODE);
@@ -1040,7 +1114,7 @@ static struct binder_ref *binder_get_ref_for_node(struct binder_proc *proc,
 		else
 			return ref;
 	}
-	new_ref = kzalloc(sizeof(*ref), GFP_KERNEL);
+	new_ref = kzalloc_nopreempt(sizeof(*ref));
 	if (new_ref == NULL)
 		return NULL;
 	binder_stats_created(BINDER_STAT_REF);
@@ -1438,14 +1512,14 @@ static void binder_transaction(struct binder_proc *proc,
 	e->to_proc = target_proc->pid;
 
 	/* TODO: reuse incoming transaction for reply */
-	t = kzalloc(sizeof(*t), GFP_KERNEL);
+	t = kzalloc_nopreempt(sizeof(*t));
 	if (t == NULL) {
 		return_error = BR_FAILED_REPLY;
 		goto err_alloc_t_failed;
 	}
 	binder_stats_created(BINDER_STAT_TRANSACTION);
 
-	tcomplete = kzalloc(sizeof(*tcomplete), GFP_KERNEL);
+	tcomplete = kzalloc_nopreempt(sizeof(*tcomplete));
 	if (tcomplete == NULL) {
 		return_error = BR_FAILED_REPLY;
 		goto err_alloc_tcomplete_failed;
@@ -1502,15 +1576,16 @@ static void binder_transaction(struct binder_proc *proc,
 	offp = (binder_size_t *)(t->buffer->data +
 				 ALIGN(tr->data_size, sizeof(void *)));
 
-	if (copy_from_user(t->buffer->data, (const void __user *)(uintptr_t)
-			   tr->data.ptr.buffer, tr->data_size)) {
+	if (copy_from_user_nopreempt(t->buffer->data,
+			(const void __user *)(uintptr_t) tr->data.ptr.buffer,
+			tr->data_size)) {
 		binder_user_error("%d:%d got transaction with invalid data ptr\n",
 				proc->pid, thread->pid);
 		return_error = BR_FAILED_REPLY;
 		goto err_copy_data_failed;
 	}
-	if (copy_from_user(offp, (const void __user *)(uintptr_t)
-			   tr->data.ptr.offsets, tr->offsets_size)) {
+	if (copy_from_user_nopreempt(offp, (const void __user *)(uintptr_t)
+				     tr->data.ptr.offsets, tr->offsets_size)) {
 		binder_user_error("%d:%d got transaction with invalid offsets ptr\n",
 				proc->pid, thread->pid);
 		return_error = BR_FAILED_REPLY;
@@ -1770,7 +1845,7 @@ static int binder_thread_write(struct binder_proc *proc,
 	void __user *end = buffer + size;
 
 	while (ptr < end && thread->return_error == BR_OK) {
-		if (get_user(cmd, (uint32_t __user *)ptr))
+		if (get_user_nopreempt(cmd, (uint32_t __user *)ptr))
 			return -EFAULT;
 		ptr += sizeof(uint32_t);
 		trace_binder_command(cmd);
@@ -1788,7 +1863,7 @@ static int binder_thread_write(struct binder_proc *proc,
 			struct binder_ref *ref;
 			const char *debug_string;
 
-			if (get_user(target, (uint32_t __user *)ptr))
+			if (get_user_nopreempt(target, (uint32_t __user *)ptr))
 				return -EFAULT;
 			ptr += sizeof(uint32_t);
 			if (target == 0 && binder_context_mgr_node &&
@@ -1838,10 +1913,12 @@ static int binder_thread_write(struct binder_proc *proc,
 			binder_uintptr_t cookie;
 			struct binder_node *node;
 
-			if (get_user(node_ptr, (binder_uintptr_t __user *)ptr))
+			if (get_user_nopreempt(node_ptr,
+					(binder_uintptr_t __user *)ptr))
 				return -EFAULT;
 			ptr += sizeof(binder_uintptr_t);
-			if (get_user(cookie, (binder_uintptr_t __user *)ptr))
+			if (get_user_nopreempt(cookie,
+					(binder_uintptr_t __user *)ptr))
 				return -EFAULT;
 			ptr += sizeof(binder_uintptr_t);
 			node = binder_get_node(proc, node_ptr);
@@ -1899,7 +1976,8 @@ static int binder_thread_write(struct binder_proc *proc,
 			binder_uintptr_t data_ptr;
 			struct binder_buffer *buffer;
 
-			if (get_user(data_ptr, (binder_uintptr_t __user *)ptr))
+			if (get_user_nopreempt(data_ptr,
+					(binder_uintptr_t __user *)ptr))
 				return -EFAULT;
 			ptr += sizeof(binder_uintptr_t);
 
@@ -1941,7 +2019,7 @@ static int binder_thread_write(struct binder_proc *proc,
 		case BC_REPLY: {
 			struct binder_transaction_data tr;
 
-			if (copy_from_user(&tr, ptr, sizeof(tr)))
+			if (copy_from_user_nopreempt(&tr, ptr, sizeof(tr)))
 				return -EFAULT;
 			ptr += sizeof(tr);
 			binder_transaction(proc, thread, &tr, cmd == BC_REPLY);
@@ -1991,10 +2069,12 @@ static int binder_thread_write(struct binder_proc *proc,
 			struct binder_ref *ref;
 			struct binder_ref_death *death;
 
-			if (get_user(target, (uint32_t __user *)ptr))
+			if (get_user_nopreempt(target,
+					(uint32_t __user *)ptr))
 				return -EFAULT;
 			ptr += sizeof(uint32_t);
-			if (get_user(cookie, (binder_uintptr_t __user *)ptr))
+			if (get_user_nopreempt(cookie,
+					(binder_uintptr_t __user *)ptr))
 				return -EFAULT;
 			ptr += sizeof(binder_uintptr_t);
 			ref = binder_get_ref(proc, target);
@@ -2023,7 +2103,7 @@ static int binder_thread_write(struct binder_proc *proc,
 						proc->pid, thread->pid);
 					break;
 				}
-				death = kzalloc(sizeof(*death), GFP_KERNEL);
+				death = kzalloc_nopreempt(sizeof(*death));
 				if (death == NULL) {
 					thread->return_error = BR_ERROR;
 					binder_debug(BINDER_DEBUG_FAILED_TRANSACTION,
@@ -2077,8 +2157,8 @@ static int binder_thread_write(struct binder_proc *proc,
 			struct binder_work *w;
 			binder_uintptr_t cookie;
 			struct binder_ref_death *death = NULL;
-
-			if (get_user(cookie, (binder_uintptr_t __user *)ptr))
+			if (get_user_nopreempt(cookie,
+					(binder_uintptr_t __user *)ptr))
 				return -EFAULT;
 
 			ptr += sizeof(cookie);
@@ -2159,7 +2239,7 @@ static int binder_thread_read(struct binder_proc *proc,
 	int wait_for_proc_work;
 
 	if (*consumed == 0) {
-		if (put_user(BR_NOOP, (uint32_t __user *)ptr))
+		if (put_user_nopreempt(BR_NOOP, (uint32_t __user *)ptr))
 			return -EFAULT;
 		ptr += sizeof(uint32_t);
 	}
@@ -2170,7 +2250,8 @@ retry:
 
 	if (thread->return_error != BR_OK && ptr < end) {
 		if (thread->return_error2 != BR_OK) {
-			if (put_user(thread->return_error2, (uint32_t __user *)ptr))
+			if (put_user_nopreempt(thread->return_error2,
+					       (uint32_t __user *)ptr))
 				return -EFAULT;
 			ptr += sizeof(uint32_t);
 			binder_stat_br(proc, thread, thread->return_error2);
@@ -2178,7 +2259,8 @@ retry:
 				goto done;
 			thread->return_error2 = BR_OK;
 		}
-		if (put_user(thread->return_error, (uint32_t __user *)ptr))
+		if (put_user_nopreempt(thread->return_error,
+				       (uint32_t __user *)ptr))
 			return -EFAULT;
 		ptr += sizeof(uint32_t);
 		binder_stat_br(proc, thread, thread->return_error);
@@ -2256,7 +2338,7 @@ retry:
 		} break;
 		case BINDER_WORK_TRANSACTION_COMPLETE: {
 			cmd = BR_TRANSACTION_COMPLETE;
-			if (put_user(cmd, (uint32_t __user *)ptr))
+			if (put_user_nopreempt(cmd, (uint32_t __user *) ptr))
 				return -EFAULT;
 			ptr += sizeof(uint32_t);
 
@@ -2298,15 +2380,16 @@ retry:
 				node->has_weak_ref = 0;
 			}
 			if (cmd != BR_NOOP) {
-				if (put_user(cmd, (uint32_t __user *)ptr))
+				if (put_user_nopreempt(cmd,
+						(uint32_t __user *) ptr))
 					return -EFAULT;
 				ptr += sizeof(uint32_t);
-				if (put_user(node->ptr,
-					     (binder_uintptr_t __user *)ptr))
+					if (put_user_nopreempt(node->ptr,
+					      (binder_uintptr_t __user *)ptr))
 					return -EFAULT;
 				ptr += sizeof(binder_uintptr_t);
-				if (put_user(node->cookie,
-					     (binder_uintptr_t __user *)ptr))
+					if (put_user_nopreempt(node->cookie,
+					      (binder_uintptr_t __user *)ptr))
 					return -EFAULT;
 				ptr += sizeof(binder_uintptr_t);
 
@@ -2349,11 +2432,12 @@ retry:
 				cmd = BR_CLEAR_DEATH_NOTIFICATION_DONE;
 			else
 				cmd = BR_DEAD_BINDER;
-			if (put_user(cmd, (uint32_t __user *)ptr))
+				if (put_user_nopreempt(cmd,
+					       (uint32_t __user *) ptr))
 				return -EFAULT;
 			ptr += sizeof(uint32_t);
-			if (put_user(death->cookie,
-				     (binder_uintptr_t __user *)ptr))
+			if (put_user_nopreempt(death->cookie,
+				       (binder_uintptr_t __user *) ptr))
 				return -EFAULT;
 			ptr += sizeof(binder_uintptr_t);
 			binder_stat_br(proc, thread, cmd);
@@ -2420,10 +2504,10 @@ retry:
 					ALIGN(t->buffer->data_size,
 					    sizeof(void *));
 
-		if (put_user(cmd, (uint32_t __user *)ptr))
+		if (put_user_nopreempt(cmd, (uint32_t __user *) ptr))
 			return -EFAULT;
 		ptr += sizeof(uint32_t);
-		if (copy_to_user(ptr, &tr, sizeof(tr)))
+		if (copy_to_user_nopreempt(ptr, &tr, sizeof(tr)))
 			return -EFAULT;
 		ptr += sizeof(tr);
 
@@ -2465,7 +2549,8 @@ done:
 		binder_debug(BINDER_DEBUG_THREADS,
 			     "%d:%d BR_SPAWN_LOOPER\n",
 			     proc->pid, thread->pid);
-		if (put_user(BR_SPAWN_LOOPER, (uint32_t __user *)buffer))
+		if (put_user_nopreempt(BR_SPAWN_LOOPER,
+				       (uint32_t __user *) buffer))
 			return -EFAULT;
 		binder_stat_br(proc, thread, BR_SPAWN_LOOPER);
 	}
@@ -2540,7 +2625,7 @@ static struct binder_thread *binder_get_thread(struct binder_proc *proc)
 			break;
 	}
 	if (*p == NULL) {
-		thread = kzalloc(sizeof(*thread), GFP_KERNEL);
+		thread = kzalloc_nopreempt(sizeof(*thread));
 		if (thread == NULL)
 			return NULL;
 		binder_stats_created(BINDER_STAT_THREAD);
@@ -2644,7 +2729,7 @@ static int binder_ioctl_write_read(struct file *filp,
 		ret = -EINVAL;
 		goto out;
 	}
-	if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
+	if (copy_from_user_nopreempt(&bwr, ubuf, sizeof(bwr))) {
 		ret = -EFAULT;
 		goto out;
 	}
@@ -2662,7 +2747,7 @@ static int binder_ioctl_write_read(struct file *filp,
 		trace_binder_write_done(ret);
 		if (ret < 0) {
 			bwr.read_consumed = 0;
-			if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
+			if (copy_to_user_nopreempt(ubuf, &bwr, sizeof(bwr)))
 				ret = -EFAULT;
 			goto out;
 		}
@@ -2676,7 +2761,7 @@ static int binder_ioctl_write_read(struct file *filp,
 		if (!list_empty(&proc->todo))
 			wake_up_interruptible(&proc->wait);
 		if (ret < 0) {
-			if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
+			if (copy_to_user_nopreempt(ubuf, &bwr, sizeof(bwr)))
 				ret = -EFAULT;
 			goto out;
 		}
@@ -2686,7 +2771,7 @@ static int binder_ioctl_write_read(struct file *filp,
 		     proc->pid, thread->pid,
 		     (u64)bwr.write_consumed, (u64)bwr.write_size,
 		     (u64)bwr.read_consumed, (u64)bwr.read_size);
-	if (copy_to_user(ubuf, &bwr, sizeof(bwr))) {
+	if (copy_to_user_nopreempt(ubuf, &bwr, sizeof(bwr))) {
 		ret = -EFAULT;
 		goto out;
 	}
@@ -2768,7 +2853,8 @@ static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 			goto err;
 		break;
 	case BINDER_SET_MAX_THREADS:
-		if (copy_from_user(&proc->max_threads, ubuf, sizeof(proc->max_threads))) {
+		if (copy_from_user_nopreempt(&proc->max_threads, ubuf,
+					     sizeof(proc->max_threads))) {
 			ret = -EINVAL;
 			goto err;
 		}
@@ -2791,9 +2877,9 @@ static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 			ret = -EINVAL;
 			goto err;
 		}
-		if (put_user(BINDER_CURRENT_PROTOCOL_VERSION,
-			     &ver->protocol_version)) {
-			ret = -EINVAL;
+			if (put_user_nopreempt(BINDER_CURRENT_PROTOCOL_VERSION,
+					       &ver->protocol_version)) {
+				ret = -EINVAL;
 			goto err;
 		}
 		break;
@@ -2854,6 +2940,7 @@ static const struct vm_operations_struct binder_vm_ops = {
 static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
 {
 	int ret;
+
 	struct vm_struct *area;
 	struct binder_proc *proc = filp->private_data;
 	const char *failure_string;
@@ -2914,7 +3001,12 @@ static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
 	vma->vm_ops = &binder_vm_ops;
 	vma->vm_private_data = proc;
 
-	if (binder_update_page_range(proc, 1, proc->buffer, proc->buffer + PAGE_SIZE, vma)) {
+	/* binder_update_page_range assumes preemption is disabled */
+	preempt_disable();
+	ret = binder_update_page_range(proc, 1, proc->buffer,
+				       proc->buffer + PAGE_SIZE, vma);
+	preempt_enable_no_resched();
+	if (ret) {
 		ret = -ENOMEM;
 		failure_string = "alloc small buf";
 		goto err_alloc_small_buf_failed;
@@ -3185,8 +3277,12 @@ static void binder_deferred_func(struct work_struct *work)
 	int defer;
 
 	do {
-		binder_lock(__func__);
+		trace_binder_lock(__func__);
+		mutex_lock(&binder_main_lock);
+		trace_binder_locked(__func__);
+
 		mutex_lock(&binder_deferred_lock);
+		preempt_disable();
 		if (!hlist_empty(&binder_deferred_list)) {
 			proc = hlist_entry(binder_deferred_list.first,
 					struct binder_proc, deferred_work_node);
@@ -3212,7 +3308,9 @@ static void binder_deferred_func(struct work_struct *work)
 		if (defer & BINDER_DEFERRED_RELEASE)
 			binder_deferred_release(proc); /* frees proc */
 
-		binder_unlock(__func__);
+		trace_binder_unlock(__func__);
+		mutex_unlock(&binder_main_lock);
+		preempt_enable_no_resched();
 		if (files)
 			put_files_struct(files);
 	} while (proc);
Signature · 1 line
2.8.0.rc3.226.g39d4020
maintainer
#1 lore raw
Quoted 7 lines · Todd Kjos

From: Todd Kjos <[email protected]>

In Android systems, the display pipeline relies on low latency binder transactions and is therefore sensitive to delays caused by contention for the global binder lock. Jank is significantly reduced by disabling preemption while the global binder lock is held.

What is the technical definition of "Jank"? :)

Quoted 64 lines

This patch was originated by Riley Andrews <[email protected]> with tweaks and forward-porting by me.

Originally-from: Riley Andrews <[email protected]>

---
 drivers/android/binder.c | 194 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 146 insertions(+), 48 deletions(-)
drivers/android/binder.c +15 -2
index 16288e7..c36e420 100644
@@ -379,6 +379,7 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 	struct files_struct *files = proc->files;
 	unsigned long rlim_cur;
 	unsigned long irqs;
+	int ret;
 
 	if (files == NULL)
 		return -ESRCH;
@@ -389,7 +390,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 	rlim_cur = task_rlimit(proc->tsk, RLIMIT_NOFILE);
 	unlock_task_sighand(proc->tsk, &irqs);
 
-	return __alloc_fd(files, 0, rlim_cur, flags);
+	preempt_enable_no_resched();
+	ret = __alloc_fd(files, 0, rlim_cur, flags);
+	preempt_disable();
+
+	return ret;
 }
 
 /*
@@ -398,8 +403,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 static void task_fd_install(
 	struct binder_proc *proc, unsigned int fd, struct file *file)
 {
-	if (proc->files)
+	if (proc->files) {
+		preempt_enable_no_resched();
 		__fd_install(proc->files, fd, file);
+		preempt_disable();
+	}
 }
 
 /*
@@ -427,6 +435,7 @@ static inline void binder_lock(const char *tag)
 {
 	trace_binder_lock(tag);
 	mutex_lock(&binder_main_lock);
+	preempt_disable();
 	trace_binder_locked(tag);
 }
 
@@ -434,8 +443,65 @@ static inline void binder_unlock(const char *tag)
 {
 	trace_binder_unlock(tag);
 	mutex_unlock(&binder_main_lock);
+	preempt_enable();
+}
+
+static inline void *kzalloc_nopreempt(size_t size)

drivers/android/binder.c static inline void binder_unlock(const char *tag) · line 459

Quoted 10 lines
drivers/android/binder.c +10 -0
+{
+	void *ptr;
+
+	ptr = kzalloc(size, GFP_NOWAIT);
+	if (ptr)
+		return ptr;
+
+	preempt_enable_no_resched();
+	ptr = kzalloc(size, GFP_KERNEL);
+	preempt_disable();

Doesn't the allocator retry if the first one fails anyway? Why not GFP_NOIO or GFP_ATOMIC? Have you really hit the second GFP_KERNEL usage?

Quoted 34 lines
drivers/android/binder.c +32 -0
+
+	return ptr;
+}
+
+static inline long copy_to_user_nopreempt(void __user *to,
+					  const void *from, long n)
+{
+	long ret;
+
+	preempt_enable_no_resched();
+	ret = copy_to_user(to, from, n);
+	preempt_disable();
+	return ret;
+}
+
+static inline long copy_from_user_nopreempt(void *to,
+					    const void __user *from,
+					    long n)
+{
+	long ret;
+
+	preempt_enable_no_resched();
+	ret = copy_from_user(to, from, n);
+	preempt_disable();
+	return ret;
 }
 
+#define get_user_nopreempt(x, ptr)	\
+({						\
+	int __ret;				\
+	preempt_enable_no_resched();		\
+	__ret = get_user(x, ptr);		\
+	preempt_disable();			\
+	__ret;					\

drivers/android/binder.c static inline void binder_unlock(const char *tag) · line 503

Quoted 10 lines
drivers/android/binder.c +10 -0
+})
+
+#define put_user_nopreempt(x, ptr)	\
+({						\
+	int __ret;				\
+	preempt_enable_no_resched();		\
+	__ret = put_user(x, ptr);		\
+	preempt_disable();			\
+	__ret;					\
+})

Any reason some of these are #defines and some are static inline functions?

Anyway, these all seem a bit strange to me, what type of latency spikes are you seeing that these changes resolve? Shouldn't that be an issue with the scheduler more than just the binder driver?

I don't know of any other driver or IPC that does this type of thing with the scheduler in order to make things "go faster", so it feels wrong to me, and is probably why we don't have global functions like put_user_nopreempt() :)

And is enabling and disabling preemption around single byte copies to/from userspace really a good idea? That seems like a lot of overhead you are now adding to your "fastpath" that you need to go even faster.

And finally, I'm guessing this has passed the binder test suite that is out there for testing binder changes? If so, can you please mention it in the changelog text?

thanks,

greg k-h

author maintainer
#2 lore raw
Quoted 10 lines · Greg KH
Quoted 7 lines · Todd Kjos

From: Todd Kjos <[email protected]>

In Android systems, the display pipeline relies on low latency binder transactions and is therefore sensitive to delays caused by contention for the global binder lock. Jank is significantly reduced by disabling preemption while the global binder lock is held.

What is the technical definition of "Jank"? :)

I'll rephrase in the next version to "dropped or delayed frames".

Quoted 71 lines
Quoted 71 lines

This patch was originated by Riley Andrews <[email protected]> with tweaks and forward-porting by me.

Originally-from: Riley Andrews <[email protected]>

---
 drivers/android/binder.c | 194 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 146 insertions(+), 48 deletions(-)
drivers/android/binder.c +21 -2
index 16288e7..c36e420 100644
@@ -379,6 +379,7 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
      struct files_struct *files = proc->files;
      unsigned long rlim_cur;
      unsigned long irqs;
+     int ret;
 
      if (files == NULL)
              return -ESRCH;
@@ -389,7 +390,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
      rlim_cur = task_rlimit(proc->tsk, RLIMIT_NOFILE);
      unlock_task_sighand(proc->tsk, &irqs);
 
-     return __alloc_fd(files, 0, rlim_cur, flags);
+     preempt_enable_no_resched();
+     ret = __alloc_fd(files, 0, rlim_cur, flags);
+     preempt_disable();
+
+     return ret;
 }
 
 /*
@@ -398,8 +403,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 static void task_fd_install(
      struct binder_proc *proc, unsigned int fd, struct file *file)
 {
-     if (proc->files)
+     if (proc->files) {
+             preempt_enable_no_resched();
              __fd_install(proc->files, fd, file);
+             preempt_disable();
+     }
 }
 
 /*
@@ -427,6 +435,7 @@ static inline void binder_lock(const char *tag)
 {
      trace_binder_lock(tag);
      mutex_lock(&binder_main_lock);
+     preempt_disable();
      trace_binder_locked(tag);
 }
 
@@ -434,8 +443,65 @@ static inline void binder_unlock(const char *tag)
 {
      trace_binder_unlock(tag);
      mutex_unlock(&binder_main_lock);
+     preempt_enable();
+}
+
+static inline void *kzalloc_nopreempt(size_t size)
+{
+     void *ptr;
+
+     ptr = kzalloc(size, GFP_NOWAIT);
+     if (ptr)
+             return ptr;
Quoted 8 lines

drivers/android/binder.c static inline void binder_unlock(const char *tag) · line 459

Quoted 4 lines
drivers/android/binder.c +4 -0
+
+     preempt_enable_no_resched();
+     ptr = kzalloc(size, GFP_KERNEL);
+     preempt_disable();

Doesn't the allocator retry if the first one fails anyway? Why not GFP_NOIO or GFP_ATOMIC? Have you really hit the second GFP_KERNEL usage?

I suspect we have hit the second, since we do get into cases where direct reclaim is needed. I can't confirm since I haven't instrumented this case. As you say, if we use GFP_ATOMIC instead, maybe we wouldn't, but even then I'd be concerned that we could deplete the memory reserved for atomic. The general idea of trying for a fast, nowait allocation and then enabling preempt for the rare potentially blocking allocation seems reasonable, doesn't it?

Quoted 39 lines
Quoted 39 lines
drivers/android/binder.c +37 -0
+
+     return ptr;
+}
+
+static inline long copy_to_user_nopreempt(void __user *to,
+                                       const void *from, long n)
+{
+     long ret;
+
+     preempt_enable_no_resched();
+     ret = copy_to_user(to, from, n);
+     preempt_disable();
+     return ret;
+}
+
+static inline long copy_from_user_nopreempt(void *to,
+                                         const void __user *from,
+                                         long n)
+{
+     long ret;
+
+     preempt_enable_no_resched();
+     ret = copy_from_user(to, from, n);
+     preempt_disable();
+     return ret;
 }
 
+#define get_user_nopreempt(x, ptr)   \
+({                                           \
+     int __ret;                              \
+     preempt_enable_no_resched();            \
+     __ret = get_user(x, ptr);               \
+     preempt_disable();                      \
+     __ret;                                  \
+})
+
+#define put_user_nopreempt(x, ptr)   \
+({                                           \
+     int __ret;                              \
Quoted 8 lines

drivers/android/binder.c static inline void binder_unlock(const char *tag) · line 503

Quoted 5 lines
drivers/android/binder.c +5 -0
+     preempt_enable_no_resched();            \
+     __ret = put_user(x, ptr);               \
+     preempt_disable();                      \
+     __ret;                                  \
+})

Any reason some of these are #defines and some are static inline functions?

Not that I know of. I'll change to static inline for the next version.

Quoted 4 lines

Anyway, these all seem a bit strange to me, what type of latency spikes are you seeing that these changes resolve? Shouldn't that be an issue with the scheduler more than just the binder driver?

Well, it certainly is partially a scheduler issue in the sense that we are using SCHED_NORMAL for latency sensitive tasks that comprise the display pipeline (surfaceflinger, UI threads, Render threads). This means that a task being preempted might have to wait for a while before getting scheduled again. It would be nice to use SCHED_FIFO for these, but at the moment we can't do that since that opens us up to user code DOS'ing cores. There are some ideas being investigated here, but that's a ways off.

It is also partially a binder issue since there is a single global mutex that is acquired for any binder transaction. There are periods where the IPC rate is very high. Most of those binder calls are not so latency sensitive that a little contention for the binder lock matters, but the binder calls between RenderThreads and Surfaceflinger are sensitive since there are frame deadlines that need to be met. The more time spent holding the binder lock, the higher probability for contention and resulting delays which can cause us to miss the deadline for the frame.

Without this change, it is common for the task holding the mutex be preempted, creating a backlog of tasks waiting on the mutex. We measured the lock being held for over 400us regularly in these cases, greatly increasing the likelyhood of contention for the mutex. Since there a several binder calls in the pipeline as part of drawing a frame, this was observed to induce more than 10ms of frame delay and sometimes as high as 20ms which translates directly to missed frames. This change fixed that issue.

Quoted 5 lines

I don't know of any other driver or IPC that does this type of thing with the scheduler in order to make things "go faster", so it feels wrong to me, and is probably why we don't have global functions like put_user_nopreempt() :)

I suspect that for most folks, "go faster" means "increase throughput". In this case "go faster" means "decrease frame render times" (or, more precisely "meet frame deadlines"). Maybe binder is special.

Quoted 4 lines

And is enabling and disabling preemption around single byte copies to/from userspace really a good idea? That seems like a lot of overhead you are now adding to your "fastpath" that you need to go even faster.

Don't the user copy functions assume that preemption is enabled? If it is safe to avoid the toggling here, then I'd agree that it isn't a "good idea". The overhead of this toggle is in the noise compared a task being preempted while holding the binder lock.

Quoted 4 lines

And finally, I'm guessing this has passed the binder test suite that is out there for testing binder changes? If so, can you please mention it in the changelog text?

Yes, it did. Will mention in the next version.

Quoted 4 lines

thanks,

greg k-h

-Todd

maintainer
#3 lore raw
Quoted 10 lines · Todd Kjos
Quoted 9 lines · Greg KH
Quoted 7 lines · Todd Kjos

From: Todd Kjos <[email protected]>

In Android systems, the display pipeline relies on low latency binder transactions and is therefore sensitive to delays caused by contention for the global binder lock. Jank is significantly reduced by disabling preemption while the global binder lock is held.

Quoted 3 lines
Quoted 1 line

What is the technical definition of "Jank"? :)

I'll rephrase in the next version to "dropped or delayed frames".

Heh, thanks :)

Also in the next version can you fix the errors found by the 0-day build bot?

Quoted 78 lines
Quoted 69 lines
Quoted 69 lines

This patch was originated by Riley Andrews <[email protected]> with tweaks and forward-porting by me.

Originally-from: Riley Andrews <[email protected]>

---
 drivers/android/binder.c | 194 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 146 insertions(+), 48 deletions(-)
drivers/android/binder.c +21 -2
index 16288e7..c36e420 100644
@@ -379,6 +379,7 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
      struct files_struct *files = proc->files;
      unsigned long rlim_cur;
      unsigned long irqs;
+     int ret;
 
      if (files == NULL)
              return -ESRCH;
@@ -389,7 +390,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
      rlim_cur = task_rlimit(proc->tsk, RLIMIT_NOFILE);
      unlock_task_sighand(proc->tsk, &irqs);
 
-     return __alloc_fd(files, 0, rlim_cur, flags);
+     preempt_enable_no_resched();
+     ret = __alloc_fd(files, 0, rlim_cur, flags);
+     preempt_disable();
+
+     return ret;
 }
 
 /*
@@ -398,8 +403,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 static void task_fd_install(
      struct binder_proc *proc, unsigned int fd, struct file *file)
 {
-     if (proc->files)
+     if (proc->files) {
+             preempt_enable_no_resched();
              __fd_install(proc->files, fd, file);
+             preempt_disable();
+     }
 }
 
 /*
@@ -427,6 +435,7 @@ static inline void binder_lock(const char *tag)
 {
      trace_binder_lock(tag);
      mutex_lock(&binder_main_lock);
+     preempt_disable();
      trace_binder_locked(tag);
 }
 
@@ -434,8 +443,65 @@ static inline void binder_unlock(const char *tag)
 {
      trace_binder_unlock(tag);
      mutex_unlock(&binder_main_lock);
+     preempt_enable();
+}
+
+static inline void *kzalloc_nopreempt(size_t size)
+{
+     void *ptr;
+
+     ptr = kzalloc(size, GFP_NOWAIT);
+     if (ptr)
+             return ptr;
Quoted 8 lines

drivers/android/binder.c static inline void binder_unlock(const char *tag) · line 459

Quoted 4 lines
drivers/android/binder.c +4 -0
+
+     preempt_enable_no_resched();
+     ptr = kzalloc(size, GFP_KERNEL);
+     preempt_disable();

Doesn't the allocator retry if the first one fails anyway? Why not GFP_NOIO or GFP_ATOMIC? Have you really hit the second GFP_KERNEL usage?

Quoted 7 lines

I suspect we have hit the second, since we do get into cases where direct reclaim is needed. I can't confirm since I haven't instrumented this case. As you say, if we use GFP_ATOMIC instead, maybe we wouldn't, but even then I'd be concerned that we could deplete the memory reserved for atomic. The general idea of trying for a fast, nowait allocation and then enabling preempt for the rare potentially blocking allocation seems reasonable, doesn't it?

Yes it is, so much so that I think there's a generic kernel function for it already. Adding in the linux-mm mailing list to be told that I'm wrong about this :)

Quoted 73 lines
Quoted 38 lines
Quoted 38 lines
drivers/android/binder.c +36 -0
+     return ptr;
+}
+
+static inline long copy_to_user_nopreempt(void __user *to,
+                                       const void *from, long n)
+{
+     long ret;
+
+     preempt_enable_no_resched();
+     ret = copy_to_user(to, from, n);
+     preempt_disable();
+     return ret;
+}
+
+static inline long copy_from_user_nopreempt(void *to,
+                                         const void __user *from,
+                                         long n)
+{
+     long ret;
+
+     preempt_enable_no_resched();
+     ret = copy_from_user(to, from, n);
+     preempt_disable();
+     return ret;
 }
 
+#define get_user_nopreempt(x, ptr)   \
+({                                           \
+     int __ret;                              \
+     preempt_enable_no_resched();            \
+     __ret = get_user(x, ptr);               \
+     preempt_disable();                      \
+     __ret;                                  \
+})
+
+#define put_user_nopreempt(x, ptr)   \
+({                                           \
+     int __ret;                              \
Quoted 8 lines

drivers/android/binder.c static inline void binder_unlock(const char *tag) · line 503

Quoted 5 lines
drivers/android/binder.c +5 -0
+     preempt_enable_no_resched();            \
+     __ret = put_user(x, ptr);               \
+     preempt_disable();                      \
+     __ret;                                  \
+})

Any reason some of these are #defines and some are static inline functions?

Not that I know of. I'll change to static inline for the next version.

Quoted 4 lines

Anyway, these all seem a bit strange to me, what type of latency spikes are you seeing that these changes resolve? Shouldn't that be an issue with the scheduler more than just the binder driver?

Well, it certainly is partially a scheduler issue in the sense that we are using SCHED_NORMAL for latency sensitive tasks that comprise the display pipeline (surfaceflinger, UI threads, Render threads). This means that a task being preempted might have to wait for a while before getting scheduled again. It would be nice to use SCHED_FIFO for these, but at the moment we can't do that since that opens us up to user code DOS'ing cores. There are some ideas being investigated here, but that's a ways off.

It is also partially a binder issue since there is a single global mutex that is acquired for any binder transaction. There are periods where the IPC rate is very high. Most of those binder calls are not so latency sensitive that a little contention for the binder lock matters, but the binder calls between RenderThreads and Surfaceflinger are sensitive since there are frame deadlines that need to be met. The more time spent holding the binder lock, the higher probability for contention and resulting delays which can cause us to miss the deadline for the frame.

Quoted 8 lines

Without this change, it is common for the task holding the mutex be preempted, creating a backlog of tasks waiting on the mutex. We measured the lock being held for over 400us regularly in these cases, greatly increasing the likelyhood of contention for the mutex. Since there a several binder calls in the pipeline as part of drawing a frame, this was observed to induce more than 10ms of frame delay and sometimes as high as 20ms which translates directly to missed frames. This change fixed that issue.

This single-mutex problem has always bothered me about binder, and it's just going to get worse with the upcoming changes in the Android systems to rely more on binder.

So perhaps that should be fixed instead of messing around with scheduling issues? Messing with the scheduler is just going to cause more and more problems over time, and make it harder to have to "tune" a system for good "jank" given the horrid hacks the vendors already do to the kernel scheduler that aren't upstream :(

Can we break the mutex up a bit? That seems like the best solution in the long run (becides moving to a bus1-based-solution which is probably much longer term...)

Quoted 9 lines
Quoted 4 lines

I don't know of any other driver or IPC that does this type of thing with the scheduler in order to make things "go faster", so it feels wrong to me, and is probably why we don't have global functions like put_user_nopreempt() :)

I suspect that for most folks, "go faster" means "increase throughput". In this case "go faster" means "decrease frame render times" (or, more precisely "meet frame deadlines"). Maybe binder is special.

Yes, binder is unique and special, just like everyone else :)

"meet frame deadlines" is a very good and specific measurement, so you are doing well there, but messing with the preempt logic to try to achieve this seems like an odd solution when the lock seems like a better long-term issue to be solved.

Quoted 5 lines
Quoted 3 lines

And is enabling and disabling preemption around single byte copies to/from userspace really a good idea? That seems like a lot of overhead you are now adding to your "fastpath" that you need to go even faster.

Don't the user copy functions assume that preemption is enabled?

Yes. Well, usually, but not always, they are messy :)

Quoted 3 lines

If it is safe to avoid the toggling here, then I'd agree that it isn't a "good idea". The overhead of this toggle is in the noise compared a task being preempted while holding the binder lock.

Yes, but you are doing this just for single character read/writes, the set-up/tear-down for doing that seems huge, shouldn't binder look to make those be a bit more "batched"? That might improve the throughput as well, as it would reduce the amount of time the global mutex was held.

thanks,

greg k-h

maintainer
#4 lore raw
Quoted 106 lines · Greg KH
Quoted 10 lines · Todd Kjos
Quoted 9 lines · Greg KH
Quoted 7 lines · Todd Kjos

From: Todd Kjos <[email protected]>

In Android systems, the display pipeline relies on low latency binder transactions and is therefore sensitive to delays caused by contention for the global binder lock. Jank is significantly reduced by disabling preemption while the global binder lock is held.

Quoted 3 lines
Quoted 1 line

What is the technical definition of "Jank"? :)

I'll rephrase in the next version to "dropped or delayed frames".

Heh, thanks :)

Also in the next version can you fix the errors found by the 0-day build bot?

Quoted 78 lines
Quoted 69 lines
Quoted 69 lines

This patch was originated by Riley Andrews <[email protected]> with tweaks and forward-porting by me.

Originally-from: Riley Andrews <[email protected]>

---
 drivers/android/binder.c | 194 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 146 insertions(+), 48 deletions(-)
drivers/android/binder.c +21 -2
index 16288e7..c36e420 100644
@@ -379,6 +379,7 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
      struct files_struct *files = proc->files;
      unsigned long rlim_cur;
      unsigned long irqs;
+     int ret;
 
      if (files == NULL)
              return -ESRCH;
@@ -389,7 +390,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
      rlim_cur = task_rlimit(proc->tsk, RLIMIT_NOFILE);
      unlock_task_sighand(proc->tsk, &irqs);
 
-     return __alloc_fd(files, 0, rlim_cur, flags);
+     preempt_enable_no_resched();
+     ret = __alloc_fd(files, 0, rlim_cur, flags);
+     preempt_disable();
+
+     return ret;
 }
 
 /*
@@ -398,8 +403,11 @@ static int task_get_unused_fd_flags(struct binder_proc *proc, int flags)
 static void task_fd_install(
      struct binder_proc *proc, unsigned int fd, struct file *file)
 {
-     if (proc->files)
+     if (proc->files) {
+             preempt_enable_no_resched();
              __fd_install(proc->files, fd, file);
+             preempt_disable();
+     }
 }
 
 /*
@@ -427,6 +435,7 @@ static inline void binder_lock(const char *tag)
 {
      trace_binder_lock(tag);
      mutex_lock(&binder_main_lock);
+     preempt_disable();
      trace_binder_locked(tag);
 }
 
@@ -434,8 +443,65 @@ static inline void binder_unlock(const char *tag)
 {
      trace_binder_unlock(tag);
      mutex_unlock(&binder_main_lock);
+     preempt_enable();
+}
+
+static inline void *kzalloc_nopreempt(size_t size)
+{
+     void *ptr;
+
+     ptr = kzalloc(size, GFP_NOWAIT);
+     if (ptr)
+             return ptr;
Quoted 8 lines

drivers/android/binder.c static inline void binder_unlock(const char *tag) · line 459

Quoted 4 lines
drivers/android/binder.c +4 -0
+
+     preempt_enable_no_resched();
+     ptr = kzalloc(size, GFP_KERNEL);
+     preempt_disable();

Doesn't the allocator retry if the first one fails anyway? Why not GFP_NOIO or GFP_ATOMIC? Have you really hit the second GFP_KERNEL usage?

Quoted 7 lines

I suspect we have hit the second, since we do get into cases where direct reclaim is needed. I can't confirm since I haven't instrumented this case. As you say, if we use GFP_ATOMIC instead, maybe we wouldn't, but even then I'd be concerned that we could deplete the memory reserved for atomic. The general idea of trying for a fast, nowait allocation and then enabling preempt for the rare potentially blocking allocation seems reasonable, doesn't it?

Quoted 3 lines

Yes it is, so much so that I think there's a generic kernel function for it already. Adding in the linux-mm mailing list to be told that I'm wrong about this :)

Ok, adding the correct linux-mm list address this time...

greg k-h

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

#5 lore raw
In reply to Todd Kjos
url: https://github.com/0day-ci/linux/commits/Todd-Kjos/android-binder-Disable-preemption-while-holding-the-global-binder-lock/20160909-233333 config: x86_64-randconfig-x008-201636 (attached as…

Hi Todd,

[auto build test WARNING on staging/staging-testing]
[also build test WARNING on v4.8-rc5 next-20160909]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]
[Suggest to use git(>=2.9.0) format-patch --base=<commit> (or --base=auto for convenience) to record what (public, well-known) commit your patch series was built on] [Check https://git-scm.com/docs/git-format-patch for more information]

url: https://github.com/0day-ci/linux/commits/Todd-Kjos/android-binder-Disable-preemption-while-holding-the-global-binder-lock/20160909-233333
config: x86_64-randconfig-x008-201636 (attached as .config)
compiler: gcc-6 (Debian 6.1.1-9) 6.1.1 20160705 reproduce:

        # save the attached .config to linux build tree
        make ARCH=x86_64 

All warnings (new ones prefixed by >>):

drivers/android/binder.c: In function 'binder_thread_read':

>> drivers/android/binder.c:2432:4: warning: this 'else' clause does not guard... [-Wmisleading-indentation]
       else
       ^~~~
   drivers/android/binder.c:2434:5: note: ...this statement, but the latter is misleadingly indented as if it is guarded by the 'else'
        if (put_user_nopreempt(cmd,
        ^~

vim +/else +2432 drivers/android/binder.c

da49889d drivers/staging/android/binder.c Arve Hjønnevåg     2014-02-21  2416  						     proc->pid, thread->pid,
da49889d drivers/staging/android/binder.c Arve Hjønnevåg     2014-02-21  2417  						     node->debug_id,
da49889d drivers/staging/android/binder.c Arve Hjønnevåg     2014-02-21  2418  						     (u64)node->ptr,
da49889d drivers/staging/android/binder.c Arve Hjønnevåg     2014-02-21  2419  						     (u64)node->cookie);
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2420  				}
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2421  			}
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2422  		} break;
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2423  		case BINDER_WORK_DEAD_BINDER:
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2424  		case BINDER_WORK_DEAD_BINDER_AND_CLEAR:
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2425  		case BINDER_WORK_CLEAR_DEATH_NOTIFICATION: {
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2426  			struct binder_ref_death *death;
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2427  			uint32_t cmd;
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2428  
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2429  			death = container_of(w, struct binder_ref_death, work);
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2430  			if (w->type == BINDER_WORK_CLEAR_DEATH_NOTIFICATION)
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2431  				cmd = BR_CLEAR_DEATH_NOTIFICATION_DONE;
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30 @2432  			else
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2433  				cmd = BR_DEAD_BINDER;
ddd4adb7 drivers/android/binder.c         Todd Kjos          2016-09-09  2434  				if (put_user_nopreempt(cmd,
ddd4adb7 drivers/android/binder.c         Todd Kjos          2016-09-09  2435  					       (uint32_t __user *) ptr))
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2436  				return -EFAULT;
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30  2437  			ptr += sizeof(uint32_t);
ddd4adb7 drivers/android/binder.c         Todd Kjos          2016-09-09  2438  			if (put_user_nopreempt(death->cookie,

da49889d drivers/staging/android/binder.c Arve Hjønnevåg 2014-02-21 2439 (binder_uintptr_t __user *) ptr))
355b0502 drivers/staging/android/binder.c Greg Kroah-Hartman 2011-11-30 2440 return -EFAULT;

:::::: The code at line 2432 was first introduced by commit
:::::: 355b0502f6efea0ff9492753888772c96972d2a3 Revert "Staging: android: delete android drivers"

:::::: TO: Greg Kroah-Hartman <[email protected]>
:::::: CC: Greg Kroah-Hartman <[email protected]>

---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation