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

+11 -22

drivers/android/binder.c

··· 1585 1585 { 1586 1586 struct binder_thread *from; 1587 1587 1588 - spin_lock(&t->lock); 1588 + guard(spinlock)(&t->lock); 1589 1589 from = t->from; 1590 1590 if (from) 1591 1591 atomic_inc(&from->tmp_ref); 1592 - spin_unlock(&t->lock); 1593 1592 return from; 1594 1593 } 1595 1594 ··· 5442 5443 struct binder_node *new_node; 5443 5444 kuid_t curr_euid = current_euid(); 5444 5445 5445 - mutex_lock(&context->context_mgr_node_lock); 5446 + guard(mutex)(&context->context_mgr_node_lock); 5446 5447 if (context->binder_context_mgr_node) { 5447 5448 pr_err("BINDER_SET_CONTEXT_MGR already set\n"); 5448 - ret = -EBUSY; 5449 - goto out; 5449 + return -EBUSY; 5450 5450 } 5451 5451 ret = security_binder_set_context_mgr(proc->cred); 5452 5452 if (ret < 0) 5453 - goto out; 5453 + return ret; 5454 5454 if (uid_valid(context->binder_context_mgr_uid)) { 5455 5455 if (!uid_eq(context->binder_context_mgr_uid, curr_euid)) { 5456 5456 pr_err("BINDER_SET_CONTEXT_MGR bad uid %d != %d\n", 5457 5457 from_kuid(&init_user_ns, curr_euid), 5458 5458 from_kuid(&init_user_ns, 5459 5459 context->binder_context_mgr_uid)); 5460 - ret = -EPERM; 5461 - goto out; 5460 + return -EPERM; 5462 5461 } 5463 5462 } else { 5464 5463 context->binder_context_mgr_uid = curr_euid; 5465 5464 } 5466 5465 new_node = binder_new_node(proc, fbo); 5467 - if (!new_node) { 5468 - ret = -ENOMEM; 5469 - goto out; 5470 - } 5466 + if (!new_node) 5467 + return -ENOMEM; 5471 5468 binder_node_lock(new_node); 5472 5469 new_node->local_weak_refs++; 5473 5470 new_node->local_strong_refs++; ··· 5472 5477 context->binder_context_mgr_node = new_node; 5473 5478 binder_node_unlock(new_node); 5474 5479 binder_put_node(new_node); 5475 - out: 5476 - mutex_unlock(&context->context_mgr_node_lock); 5477 5480 return ret; 5478 5481 } 5479 5482 ··· 6313 6320 static void 6314 6321 binder_defer_work(struct binder_proc *proc, enum binder_deferred_state defer) 6315 6322 { 6316 - mutex_lock(&binder_deferred_lock); 6323 + guard(mutex)(&binder_deferred_lock); 6317 6324 proc->deferred_work |= defer; 6318 6325 if (hlist_unhashed(&proc->deferred_work_node)) { 6319 6326 hlist_add_head(&proc->deferred_work_node, 6320 6327 &binder_deferred_list); 6321 6328 schedule_work(&binder_deferred_work); 6322 6329 } 6323 - mutex_unlock(&binder_deferred_lock); 6324 6330 } 6325 6331 6326 6332 static void print_binder_transaction_ilocked(struct seq_file *m, ··· 6861 6869 struct binder_proc *itr; 6862 6870 int pid = (unsigned long)m->private; 6863 6871 6864 - mutex_lock(&binder_procs_lock); 6872 + guard(mutex)(&binder_procs_lock); 6865 6873 hlist_for_each_entry(itr, &binder_procs, proc_node) { 6866 6874 if (itr->pid == pid) { 6867 6875 seq_puts(m, "binder proc state:\n"); 6868 6876 print_binder_proc(m, itr, true, false); 6869 6877 } 6870 6878 } 6871 - mutex_unlock(&binder_procs_lock); 6872 6879 6873 6880 return 0; 6874 6881 } ··· 6985 6994 6986 6995 void binder_add_device(struct binder_device *device) 6987 6996 { 6988 - spin_lock(&binder_devices_lock); 6997 + guard(spinlock)(&binder_devices_lock); 6989 6998 hlist_add_head(&device->hlist, &binder_devices); 6990 - spin_unlock(&binder_devices_lock); 6991 6999 } 6992 7000 6993 7001 void binder_remove_device(struct binder_device *device) 6994 7002 { 6995 - spin_lock(&binder_devices_lock); 7003 + guard(spinlock)(&binder_devices_lock); 6996 7004 hlist_del_init(&device->hlist); 6997 - spin_unlock(&binder_devices_lock); 6998 7005 } 6999 7006 7000 7007 static int __init init_binder_device(const char *name)

+4 -10

drivers/android/binder_alloc.c

··· 167 167 struct binder_buffer *binder_alloc_prepare_to_free(struct binder_alloc *alloc, 168 168 unsigned long user_ptr) 169 169 { 170 - struct binder_buffer *buffer; 171 - 172 - mutex_lock(&alloc->mutex); 173 - buffer = binder_alloc_prepare_to_free_locked(alloc, user_ptr); 174 - mutex_unlock(&alloc->mutex); 175 - return buffer; 170 + guard(mutex)(&alloc->mutex); 171 + return binder_alloc_prepare_to_free_locked(alloc, user_ptr); 176 172 } 177 173 178 174 static inline void ··· 1039 1043 struct binder_buffer *buffer; 1040 1044 struct rb_node *n; 1041 1045 1042 - mutex_lock(&alloc->mutex); 1046 + guard(mutex)(&alloc->mutex); 1043 1047 for (n = rb_first(&alloc->allocated_buffers); n; n = rb_next(n)) { 1044 1048 buffer = rb_entry(n, struct binder_buffer, rb_node); 1045 1049 seq_printf(m, " buffer %d: %lx size %zd:%zd:%zd %s\n", ··· 1049 1053 buffer->extra_buffers_size, 1050 1054 buffer->transaction ? "active" : "delivered"); 1051 1055 } 1052 - mutex_unlock(&alloc->mutex); 1053 1056 } 1054 1057 1055 1058 /** ··· 1097 1102 struct rb_node *n; 1098 1103 int count = 0; 1099 1104 1100 - mutex_lock(&alloc->mutex); 1105 + guard(mutex)(&alloc->mutex); 1101 1106 for (n = rb_first(&alloc->allocated_buffers); n != NULL; n = rb_next(n)) 1102 1107 count++; 1103 - mutex_unlock(&alloc->mutex); 1104 1108 return count; 1105 1109 } 1106 1110

+2 -6

drivers/android/binder_alloc.h

··· 160 160 static inline size_t 161 161 binder_alloc_get_free_async_space(struct binder_alloc *alloc) 162 162 { 163 - size_t free_async_space; 164 - 165 - mutex_lock(&alloc->mutex); 166 - free_async_space = alloc->free_async_space; 167 - mutex_unlock(&alloc->mutex); 168 - return free_async_space; 163 + guard(mutex)(&alloc->mutex); 164 + return alloc->free_async_space; 169 165 } 170 166 171 167 unsigned long

Configure Feed

Configure Feed