Commit 01afddca authored by Dmitry Antipov's avatar Dmitry Antipov Committed by Greg Kroah-Hartman
Browse files

binder: use guards for plain mutex- and spinlock-protected sections 



Use 'guard(mutex)' and 'guard(spinlock)' for plain (i.e. non-scoped)
mutex- and spinlock-protected sections, respectively, thus making
locking a bit simpler. Briefly tested with 'stress-ng --binderfs'.

Signed-off-by: default avatarDmitry Antipov <dmantipov@yandex.ru>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Acked-by: default avatarCarlos Llamas <cmllamas@google.com>
Link: https://lore.kernel.org/r/20250626073054.7706-2-dmantipov@yandex.ru


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 1da2dca2

drivers/android/binder.c

+11 −22
Original line number Diff line number Diff line
@@ -1585,11 +1585,10 @@ static struct binder_thread *binder_get_txn_from( 
{

	struct binder_thread *from;



	spin_lock(&t->lock);

	guard(spinlock)(&t->lock);

	from = t->from;

	if (from)

		atomic_inc(&from->tmp_ref);

	spin_unlock(&t->lock);

	return from;

}
@@ -5443,32 +5442,28 @@ static int binder_ioctl_set_ctx_mgr(struct file *filp, 
	struct binder_node *new_node;

	kuid_t curr_euid = current_euid();



	mutex_lock(&context->context_mgr_node_lock);

	guard(mutex)(&context->context_mgr_node_lock);

	if (context->binder_context_mgr_node) {

		pr_err("BINDER_SET_CONTEXT_MGR already set\n");

		ret = -EBUSY;

		goto out;

		return -EBUSY;

	}

	ret = security_binder_set_context_mgr(proc->cred);

	if (ret < 0)

		goto out;

		return ret;

	if (uid_valid(context->binder_context_mgr_uid)) {

		if (!uid_eq(context->binder_context_mgr_uid, curr_euid)) {

			pr_err("BINDER_SET_CONTEXT_MGR bad uid %d != %d\n",

			       from_kuid(&init_user_ns, curr_euid),

			       from_kuid(&init_user_ns,

					 context->binder_context_mgr_uid));

			ret = -EPERM;

			goto out;

			return -EPERM;

		}

	} else {

		context->binder_context_mgr_uid = curr_euid;

	}

	new_node = binder_new_node(proc, fbo);

	if (!new_node) {

		ret = -ENOMEM;

		goto out;

	}

	if (!new_node)

		return -ENOMEM;

	binder_node_lock(new_node);

	new_node->local_weak_refs++;

	new_node->local_strong_refs++;
@@ -5477,8 +5472,6 @@ static int binder_ioctl_set_ctx_mgr(struct file *filp, 
	context->binder_context_mgr_node = new_node;

	binder_node_unlock(new_node);

	binder_put_node(new_node);

out:

	mutex_unlock(&context->context_mgr_node_lock);

	return ret;

}
@@ -6320,14 +6313,13 @@ static DECLARE_WORK(binder_deferred_work, binder_deferred_func); 
static void

binder_defer_work(struct binder_proc *proc, enum binder_deferred_state defer)

{

	mutex_lock(&binder_deferred_lock);

	guard(mutex)(&binder_deferred_lock);

	proc->deferred_work |= defer;

	if (hlist_unhashed(&proc->deferred_work_node)) {

		hlist_add_head(&proc->deferred_work_node,

				&binder_deferred_list);

		schedule_work(&binder_deferred_work);

	}

	mutex_unlock(&binder_deferred_lock);

}



static void print_binder_transaction_ilocked(struct seq_file *m,
@@ -6869,14 +6861,13 @@ static int proc_show(struct seq_file *m, void *unused) 
	struct binder_proc *itr;

	int pid = (unsigned long)m->private;



	mutex_lock(&binder_procs_lock);

	guard(mutex)(&binder_procs_lock);

	hlist_for_each_entry(itr, &binder_procs, proc_node) {

		if (itr->pid == pid) {

			seq_puts(m, "binder proc state:\n");

			print_binder_proc(m, itr, true, false);

		}

	}

	mutex_unlock(&binder_procs_lock);



	return 0;

}
@@ -6994,16 +6985,14 @@ const struct binder_debugfs_entry binder_debugfs_entries[] = { 


void binder_add_device(struct binder_device *device)

{

	spin_lock(&binder_devices_lock);

	guard(spinlock)(&binder_devices_lock);

	hlist_add_head(&device->hlist, &binder_devices);

	spin_unlock(&binder_devices_lock);

}



void binder_remove_device(struct binder_device *device)

{

	spin_lock(&binder_devices_lock);

	guard(spinlock)(&binder_devices_lock);

	hlist_del_init(&device->hlist);

	spin_unlock(&binder_devices_lock);

}



static int __init init_binder_device(const char *name)

drivers/android/binder_alloc.c

+4 −10
Original line number Diff line number Diff line
@@ -167,12 +167,8 @@ static struct binder_buffer *binder_alloc_prepare_to_free_locked( 
struct binder_buffer *binder_alloc_prepare_to_free(struct binder_alloc *alloc,

						   unsigned long user_ptr)

{

	struct binder_buffer *buffer;



	mutex_lock(&alloc->mutex);

	buffer = binder_alloc_prepare_to_free_locked(alloc, user_ptr);

	mutex_unlock(&alloc->mutex);

	return buffer;

	guard(mutex)(&alloc->mutex);

	return binder_alloc_prepare_to_free_locked(alloc, user_ptr);

}



static inline void
@@ -1043,7 +1039,7 @@ void binder_alloc_print_allocated(struct seq_file *m, 
	struct binder_buffer *buffer;

	struct rb_node *n;



	mutex_lock(&alloc->mutex);

	guard(mutex)(&alloc->mutex);

	for (n = rb_first(&alloc->allocated_buffers); n; n = rb_next(n)) {

		buffer = rb_entry(n, struct binder_buffer, rb_node);

		seq_printf(m, "  buffer %d: %lx size %zd:%zd:%zd %s\n",
@@ -1053,7 +1049,6 @@ void binder_alloc_print_allocated(struct seq_file *m, 
			   buffer->extra_buffers_size,

			   buffer->transaction ? "active" : "delivered");

	}

	mutex_unlock(&alloc->mutex);

}



/**
@@ -1102,10 +1097,9 @@ int binder_alloc_get_allocated_count(struct binder_alloc *alloc) 
	struct rb_node *n;

	int count = 0;



	mutex_lock(&alloc->mutex);

	guard(mutex)(&alloc->mutex);

	for (n = rb_first(&alloc->allocated_buffers); n != NULL; n = rb_next(n))

		count++;

	mutex_unlock(&alloc->mutex);

	return count;

}

drivers/android/binder_alloc.h

+2 −6
Original line number Diff line number Diff line
@@ -160,12 +160,8 @@ void binder_alloc_print_pages(struct seq_file *m, 
static inline size_t

binder_alloc_get_free_async_space(struct binder_alloc *alloc)

{

	size_t free_async_space;



	mutex_lock(&alloc->mutex);

	free_async_space = alloc->free_async_space;

	mutex_unlock(&alloc->mutex);

	return free_async_space;

	guard(mutex)(&alloc->mutex);

	return alloc->free_async_space;

}



unsigned long