tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

driver core: Use guards for simple mutex locks

Guards can help to make the code more readable. So use it wherever they
do so.

Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Link: https://lore.kernel.org/r/20240821154839.604259-4-andriy.shevchenko@linux.intel.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Andy Shevchenko and committed by
Greg Kroah-Hartman adcae204 a355a465

+22 -28
+22 -28
drivers/base/core.c
··· 98 98 int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup, 99 99 u8 flags) 100 100 { 101 - int ret; 101 + guard(mutex)(&fwnode_link_lock); 102 102 103 - mutex_lock(&fwnode_link_lock); 104 - ret = __fwnode_link_add(con, sup, flags); 105 - mutex_unlock(&fwnode_link_lock); 106 - return ret; 103 + return __fwnode_link_add(con, sup, flags); 107 104 } 108 105 109 106 /** ··· 141 144 { 142 145 struct fwnode_link *link, *tmp; 143 146 144 - mutex_lock(&fwnode_link_lock); 147 + guard(mutex)(&fwnode_link_lock); 148 + 145 149 list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) 146 150 __fwnode_link_del(link); 147 - mutex_unlock(&fwnode_link_lock); 148 151 } 149 152 150 153 /** ··· 157 160 { 158 161 struct fwnode_link *link, *tmp; 159 162 160 - mutex_lock(&fwnode_link_lock); 163 + guard(mutex)(&fwnode_link_lock); 164 + 161 165 list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) 162 166 __fwnode_link_del(link); 163 - mutex_unlock(&fwnode_link_lock); 164 167 } 165 168 166 169 /** ··· 1056 1059 * Device waiting for supplier to become available is not allowed to 1057 1060 * probe. 1058 1061 */ 1059 - mutex_lock(&fwnode_link_lock); 1060 - sup_fw = fwnode_links_check_suppliers(dev->fwnode); 1061 - if (sup_fw) { 1062 - if (!dev_is_best_effort(dev)) { 1063 - fwnode_ret = -EPROBE_DEFER; 1064 - dev_err_probe(dev, -EPROBE_DEFER, 1065 - "wait for supplier %pfwf\n", sup_fw); 1066 - } else { 1067 - fwnode_ret = -EAGAIN; 1062 + scoped_guard(mutex, &fwnode_link_lock) { 1063 + sup_fw = fwnode_links_check_suppliers(dev->fwnode); 1064 + if (sup_fw) { 1065 + if (dev_is_best_effort(dev)) 1066 + fwnode_ret = -EAGAIN; 1067 + else 1068 + return dev_err_probe(dev, -EPROBE_DEFER, 1069 + "wait for supplier %pfwf\n", sup_fw); 1068 1070 } 1069 1071 } 1070 - mutex_unlock(&fwnode_link_lock); 1071 - if (fwnode_ret == -EPROBE_DEFER) 1072 - return fwnode_ret; 1073 1072 1074 1073 device_links_write_lock(); 1075 1074 ··· 1240 1247 bool val; 1241 1248 1242 1249 device_lock(dev); 1243 - mutex_lock(&fwnode_link_lock); 1244 - val = !!fwnode_links_check_suppliers(dev->fwnode); 1245 - mutex_unlock(&fwnode_link_lock); 1250 + scoped_guard(mutex, &fwnode_link_lock) 1251 + val = !!fwnode_links_check_suppliers(dev->fwnode); 1246 1252 device_unlock(dev); 1247 1253 return sysfs_emit(buf, "%u\n", val); 1248 1254 } ··· 1314 1322 */ 1315 1323 if (dev->fwnode && dev->fwnode->dev == dev) { 1316 1324 struct fwnode_handle *child; 1325 + 1317 1326 fwnode_links_purge_suppliers(dev->fwnode); 1318 - mutex_lock(&fwnode_link_lock); 1327 + 1328 + guard(mutex)(&fwnode_link_lock); 1329 + 1319 1330 fwnode_for_each_available_child_node(dev->fwnode, child) 1320 1331 __fw_devlink_pickup_dangling_consumers(child, 1321 1332 dev->fwnode); 1322 1333 __fw_devlink_link_to_consumers(dev); 1323 - mutex_unlock(&fwnode_link_lock); 1324 1334 } 1325 1335 device_remove_file(dev, &dev_attr_waiting_for_supplier); 1326 1336 ··· 2331 2337 2332 2338 fw_devlink_parse_fwtree(fwnode); 2333 2339 2334 - mutex_lock(&fwnode_link_lock); 2340 + guard(mutex)(&fwnode_link_lock); 2341 + 2335 2342 __fw_devlink_link_to_consumers(dev); 2336 2343 __fw_devlink_link_to_suppliers(dev, fwnode); 2337 - mutex_unlock(&fwnode_link_lock); 2338 2344 } 2339 2345 2340 2346 /* Device links support end. */