Convert mutex_lock()/mutex_unlock() pairs to the guard() and scoped_guard() cleanup helpers where possible. This removes error-prone goto-based unlock paths and makes it harder to forget to release a mutex on an early return.

Signed-off-by: Omer PALA palaomer100@gmail.com --- drivers/staging/greybus/arche-platform.c | 29 +++---- drivers/staging/greybus/audio_codec.c | 97 ++++++++++-------------- drivers/staging/greybus/audio_helper.c | 3 +- drivers/staging/greybus/audio_topology.c | 10 +-- drivers/staging/greybus/authentication.c | 34 ++++----- drivers/staging/greybus/bootrom.c | 11 ++- drivers/staging/greybus/camera.c | 60 +++++++-------- drivers/staging/greybus/fw-download.c | 31 ++++---- drivers/staging/greybus/fw-management.c | 38 ++++------ drivers/staging/greybus/light.c | 44 +++++------ drivers/staging/greybus/loopback.c | 39 +++++----- drivers/staging/greybus/power_supply.c | 42 ++++------ drivers/staging/greybus/raw.c | 25 +++--- drivers/staging/greybus/sdio.c | 25 +++--- drivers/staging/greybus/uart.c | 30 +++----- 15 files changed, 216 insertions(+), 302 deletions(-)

diff --git a/drivers/staging/greybus/arche-platform.c b/drivers/staging/greybus/arche-platform.c index de5de59ea..02322fce0 100644 --- a/drivers/staging/greybus/arche-platform.c +++ b/drivers/staging/greybus/arche-platform.c @@ -310,20 +310,19 @@ static ssize_t state_store(struct device *dev, struct arche_platform_drvdata *arche_pdata = dev_get_drvdata(dev); int ret = 0;

- mutex_lock(&arche_pdata->platform_state_mutex); + guard(mutex)(&arche_pdata->platform_state_mutex);

if (sysfs_streq(buf, "off")) { if (arche_pdata->state == ARCHE_PLATFORM_STATE_OFF) - goto exit; + return count;

/* If SVC goes down, bring down APB's as well */ device_for_each_child(arche_pdata->dev, NULL, apb_poweroff);

arche_platform_poweroff_seq(arche_pdata); - } else if (sysfs_streq(buf, "active")) { if (arche_pdata->state == ARCHE_PLATFORM_STATE_ACTIVE) - goto exit; + return count;

/* First we want to make sure we power off everything * and then activate back again @@ -334,16 +333,15 @@ static ssize_t state_store(struct device *dev, arche_platform_wd_irq_en(arche_pdata); ret = arche_platform_coldboot_seq(arche_pdata); if (ret) - goto exit; - + return ret; } else if (sysfs_streq(buf, "standby")) { if (arche_pdata->state == ARCHE_PLATFORM_STATE_STANDBY) - goto exit; + return count;

dev_warn(arche_pdata->dev, "standby state not supported\n"); } else if (sysfs_streq(buf, "fw_flashing")) { if (arche_pdata->state == ARCHE_PLATFORM_STATE_FW_FLASHING) - goto exit; + return count;

/* * Here we only control SVC. @@ -356,15 +354,11 @@ static ssize_t state_store(struct device *dev,

ret = arche_platform_fw_flashing_seq(arche_pdata); if (ret) - goto exit; + return ret ? ret : count; } else { dev_err(arche_pdata->dev, "unknown state\n"); - ret = -EINVAL; + return -EINVAL; } - -exit: - mutex_unlock(&arche_pdata->platform_state_mutex); - return ret ? ret : count; }

static ssize_t state_show(struct device *dev, @@ -396,7 +390,7 @@ static int arche_platform_pm_notifier(struct notifier_block *notifier, pm_notifier); int ret = NOTIFY_DONE;

- mutex_lock(&arche_pdata->platform_state_mutex); + guard(mutex)(&arche_pdata->platform_state_mutex); switch (pm_event) { case PM_SUSPEND_PREPARE: if (arche_pdata->state != ARCHE_PLATFORM_STATE_ACTIVE) { @@ -416,7 +410,6 @@ static int arche_platform_pm_notifier(struct notifier_block *notifier, default: break; } - mutex_unlock(&arche_pdata->platform_state_mutex);

return ret; } @@ -530,15 +523,13 @@ static int arche_platform_probe(struct platform_device *pdev)

/* Explicitly power off if requested */ if (!of_property_read_bool(pdev->dev.of_node, "arche,init-off")) { - mutex_lock(&arche_pdata->platform_state_mutex); + guard(mutex)(&arche_pdata->platform_state_mutex); ret = arche_platform_coldboot_seq(arche_pdata); if (ret) { - mutex_unlock(&arche_pdata->platform_state_mutex); dev_err(dev, "Failed to cold boot svc %d\n", ret); goto err_unregister_pm_notifier; } arche_platform_wd_irq_en(arche_pdata); - mutex_unlock(&arche_pdata->platform_state_mutex); }

dev_info(dev, "Device registered successfully\n"); diff --git a/drivers/staging/greybus/audio_codec.c b/drivers/staging/greybus/audio_codec.c index 6daa4e706..92d3cd4ae 100644 --- a/drivers/staging/greybus/audio_codec.c +++ b/drivers/staging/greybus/audio_codec.c @@ -316,7 +316,7 @@ int gbaudio_module_update(struct gbaudio_codec_info *codec, return -EINVAL; }

- mutex_lock(&codec->lock); + guard(mutex)(&codec->lock); if (w->id == snd_soc_dapm_aif_in) { if (enable) ret = gbaudio_module_enable_tx(codec, module, dai_id); @@ -329,8 +329,6 @@ int gbaudio_module_update(struct gbaudio_codec_info *codec, ret = gbaudio_module_disable_rx(module, dai_id); }

- mutex_unlock(&codec->lock); - return ret; } EXPORT_SYMBOL(gbaudio_module_update); @@ -344,22 +342,19 @@ static int gbcodec_startup(struct snd_pcm_substream *substream, struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev); struct gbaudio_stream_params *params;

- mutex_lock(&codec->lock); - - if (list_empty(&codec->module_list)) { - dev_err(codec->dev, "No codec module available\n"); - mutex_unlock(&codec->lock); - return -ENODEV; - } + scoped_guard(mutex, &codec->lock) { + if (list_empty(&codec->module_list)) { + dev_err(codec->dev, "No codec module available\n"); + return -ENODEV; + }

- params = find_dai_stream_params(codec, dai->id, substream->stream); - if (!params) { - dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); - mutex_unlock(&codec->lock); - return -EINVAL; + params = find_dai_stream_params(codec, dai->id, substream->stream); + if (!params) { + dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); + return -EINVAL; + } + params->state = GBAUDIO_CODEC_STARTUP; } - params->state = GBAUDIO_CODEC_STARTUP; - mutex_unlock(&codec->lock); /* to prevent suspend in case of active audio */ pm_stay_awake(dai->dev);

@@ -372,19 +367,19 @@ static void gbcodec_shutdown(struct snd_pcm_substream *substream, struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev); struct gbaudio_stream_params *params;

- mutex_lock(&codec->lock);

- if (list_empty(&codec->module_list)) - dev_info(codec->dev, "No codec module available during shutdown\n"); + scoped_guard(mutex, &codec->lock) { + if (list_empty(&codec->module_list)) + dev_info(codec->dev, "No codec module available during shutdown\n");

- params = find_dai_stream_params(codec, dai->id, substream->stream); - if (!params) { - dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); - mutex_unlock(&codec->lock); - return; + params = find_dai_stream_params(codec, dai->id, substream->stream); + if (!params) { + dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); + return; + } + params->state = GBAUDIO_CODEC_SHUTDOWN; } - params->state = GBAUDIO_CODEC_SHUTDOWN; - mutex_unlock(&codec->lock); + pm_relax(dai->dev); }

@@ -401,11 +396,10 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev); struct gbaudio_stream_params *params;

- mutex_lock(&codec->lock); + guard(mutex)(&codec->lock);

if (list_empty(&codec->module_list)) { dev_err(codec->dev, "No codec module available\n"); - mutex_unlock(&codec->lock); return -ENODEV; }

@@ -416,7 +410,6 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, if (params_channels(hwparams) != 2) { dev_err(dai->dev, "Invalid channel count:%d\n", params_channels(hwparams)); - mutex_unlock(&codec->lock); return -EINVAL; } channels = params_channels(hwparams); @@ -424,14 +417,12 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, if (params_rate(hwparams) != 48000) { dev_err(dai->dev, "Invalid sampling rate:%d\n", params_rate(hwparams)); - mutex_unlock(&codec->lock); return -EINVAL; } rate = GB_AUDIO_PCM_RATE_48000;

if (params_format(hwparams) != SNDRV_PCM_FORMAT_S16_LE) { dev_err(dai->dev, "Invalid format:%d\n", params_format(hwparams)); - mutex_unlock(&codec->lock); return -EINVAL; } format = GB_AUDIO_PCM_FMT_S16_LE; @@ -445,21 +436,18 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream,

if (!data) { dev_err(dai->dev, "DATA connection missing\n"); - mutex_unlock(&codec->lock); return -EINVAL; }

params = find_dai_stream_params(codec, dai->id, substream->stream); if (!params) { dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); - mutex_unlock(&codec->lock); return -EINVAL; }

bundle = to_gb_bundle(module->dev); ret = gb_pm_runtime_get_sync(bundle); if (ret) { - mutex_unlock(&codec->lock); return ret; }

@@ -471,7 +459,6 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, dev_err_ratelimited(dai->dev, "%d: Error during set_config\n", ret); gb_pm_runtime_put_noidle(bundle); - mutex_unlock(&codec->lock); return ret; }

@@ -488,13 +475,17 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream, params->channels = channels; params->sig_bits = sig_bits;

- mutex_unlock(&codec->lock); return 0; }

static int gbcodec_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { + /* + * Keep explicit mutex_lock/unlock here instead of guard(mutex) + * to release the lock before calling dev_err_ratelimited() and PM calls. + */ + int ret; struct gbaudio_module_info *module = NULL, *iter; struct gbaudio_data_connection *data; @@ -572,12 +563,11 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream) dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute, stream ? "CAPTURE" : "PLAYBACK");

- mutex_lock(&codec->lock); + guard(mutex)(&codec->lock);

params = find_dai_stream_params(codec, dai->id, stream); if (!params) { dev_err(codec->dev, "Failed to fetch dai_stream pointer\n"); - mutex_unlock(&codec->lock); return -EINVAL; }

@@ -589,7 +579,6 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream) } else { ret = -ENODEV; } - mutex_unlock(&codec->lock); return ret; }

@@ -604,14 +593,12 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream) if (!data) { dev_err(dai->dev, "%s DATA connection missing\n", dai->name); - mutex_unlock(&codec->lock); return -ENODEV; }

bundle = to_gb_bundle(module->dev); ret = gb_pm_runtime_get_sync(bundle); if (ret) { - mutex_unlock(&codec->lock); return ret; }

@@ -646,7 +633,6 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream) stream ? "Capture" : "Playback", ret);

gb_pm_runtime_put_noidle(bundle); - mutex_unlock(&codec->lock); return ret; }

@@ -817,19 +803,17 @@ int gbaudio_register_module(struct gbaudio_module_info *module) comp = gbcodec->component; dapm = snd_soc_component_to_dapm(comp);

- mutex_lock(&gbcodec->register_mutex); + guard(mutex)(&gbcodec->register_mutex);

if (module->num_dais) { dev_err(gbcodec->dev, "%d:DAIs not supported via gbcodec driver\n", module->num_dais); - mutex_unlock(&gbcodec->register_mutex); return -EINVAL; }

ret = gbaudio_init_jack(module, comp->card); if (ret) { - mutex_unlock(&gbcodec->register_mutex); return ret; }

@@ -858,15 +842,14 @@ int gbaudio_register_module(struct gbaudio_module_info *module) #endif }

- mutex_lock(&gbcodec->lock); - list_add(&module->list, &gbcodec->module_list); - mutex_unlock(&gbcodec->lock); + scoped_guard(mutex, &gbcodec->lock) { + list_add(&module->list, &gbcodec->module_list); + }

if (comp->card->instantiated) ret = snd_soc_dapm_new_widgets(comp->card); dev_dbg(comp->dev, "Registered %s module\n", module->name);

- mutex_unlock(&gbcodec->register_mutex); return ret; } EXPORT_SYMBOL(gbaudio_register_module); @@ -939,12 +922,12 @@ void gbaudio_unregister_module(struct gbaudio_module_info *module)

dev_dbg(comp->dev, "Unregister %s module\n", module->name);

- mutex_lock(&gbcodec->register_mutex); - mutex_lock(&gbcodec->lock); - gbaudio_codec_cleanup(module); - list_del(&module->list); - dev_dbg(comp->dev, "Process Unregister %s module\n", module->name); - mutex_unlock(&gbcodec->lock); + guard(mutex)(&gbcodec->register_mutex); + scoped_guard(mutex, &gbcodec->lock) { + gbaudio_codec_cleanup(module); + list_del(&module->list); + dev_dbg(comp->dev, "Process Unregister %s module\n", module->name); + }

#ifdef CONFIG_SND_JACK /* free jack devices for this module jack_list */ @@ -991,8 +974,6 @@ void gbaudio_unregister_module(struct gbaudio_module_info *module) }

dev_dbg(comp->dev, "Unregistered %s module\n", module->name); - - mutex_unlock(&gbcodec->register_mutex); } EXPORT_SYMBOL(gbaudio_unregister_module);

diff --git a/drivers/staging/greybus/audio_helper.c b/drivers/staging/greybus/audio_helper.c index b4873c6d6..eeb2ca7a5 100644 --- a/drivers/staging/greybus/audio_helper.c +++ b/drivers/staging/greybus/audio_helper.c @@ -117,7 +117,7 @@ int gbaudio_dapm_free_controls(struct snd_soc_dapm_context *dapm, struct snd_soc_dapm_widget *w, *tmp_w; struct snd_soc_card *card = snd_soc_dapm_to_card(dapm);

- mutex_lock(&card->dapm_mutex); + guard(mutex)(&card->dapm_mutex); for (i = 0; i < num; i++) { /* below logic can be optimized to identify widget pointer */ w = NULL; @@ -137,7 +137,6 @@ int gbaudio_dapm_free_controls(struct snd_soc_dapm_context *dapm, widget++; gbaudio_dapm_free_widget(w); } - mutex_unlock(&card->dapm_mutex); return 0; }

diff --git a/drivers/staging/greybus/audio_topology.c b/drivers/staging/greybus/audio_topology.c index 76146f91c..295625a48 100644 --- a/drivers/staging/greybus/audio_topology.c +++ b/drivers/staging/greybus/audio_topology.c @@ -33,14 +33,12 @@ static struct gbaudio_module_info *find_gb_module(struct gbaudio_codec_info *cod

dev_dbg(codec->dev, "%s:Find module#%d\n", __func__, dev_id);

- mutex_lock(&codec->lock); - list_for_each_entry(module, &codec->module_list, list) { - if (module->dev_id == dev_id) { - mutex_unlock(&codec->lock); - return module; + scoped_guard(mutex, &codec->lock) { + list_for_each_entry(module, &codec->module_list, list) { + if (module->dev_id == dev_id) + return module; } } - mutex_unlock(&codec->lock); dev_warn(codec->dev, "%s: module#%d missing in codec list\n", name, dev_id); return NULL; diff --git a/drivers/staging/greybus/authentication.c b/drivers/staging/greybus/authentication.c index d8f2cd432..5c0bfc9b0 100644 --- a/drivers/staging/greybus/authentication.c +++ b/drivers/staging/greybus/authentication.c @@ -65,20 +65,17 @@ static struct gb_cap *get_cap(struct cdev *cdev) { struct gb_cap *cap;

- mutex_lock(&list_mutex); + guard(mutex)(&list_mutex);

list_for_each_entry(cap, &cap_list, node) { if (&cap->cdev == cdev) { kref_get(&cap->kref); - goto unlock; + return cap; } }

cap = NULL;

-unlock: - mutex_unlock(&list_mutex); - return cap; }

@@ -276,7 +273,7 @@ static long cap_ioctl_unlocked(struct file *file, unsigned int cmd, * the connection is getting disconnected, so that we don't start any * new operations. */ - mutex_lock(&cap->mutex); + guard(mutex)(&cap->mutex); if (!cap->disabled) { ret = gb_pm_runtime_get_sync(bundle); if (!ret) { @@ -284,7 +281,6 @@ static long cap_ioctl_unlocked(struct file *file, unsigned int cmd, gb_pm_runtime_put_autosuspend(bundle); } } - mutex_unlock(&cap->mutex);

return ret; } @@ -314,9 +310,9 @@ int gb_cap_connection_init(struct gb_connection *connection) gb_connection_set_data(connection, cap); kref_init(&cap->kref);

- mutex_lock(&list_mutex); - list_add(&cap->node, &cap_list); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_add(&cap->node, &cap_list); + }

ret = gb_connection_enable(connection); if (ret) @@ -353,9 +349,9 @@ int gb_cap_connection_init(struct gb_connection *connection) err_connection_disable: gb_connection_disable(connection); err_list_del: - mutex_lock(&list_mutex); - list_del(&cap->node); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_del(&cap->node); + }

put_cap(cap);

@@ -379,17 +375,17 @@ void gb_cap_connection_exit(struct gb_connection *connection) * Disallow any new ioctl operations on the char device and wait for * existing ones to finish. */ - mutex_lock(&cap->mutex); - cap->disabled = true; - mutex_unlock(&cap->mutex); + scoped_guard(mutex, &cap->mutex) { + cap->disabled = true; + }

/* All pending greybus operations should have finished by now */ gb_connection_disable(cap->connection);

/* Disallow new users to get access to the cap structure */ - mutex_lock(&list_mutex); - list_del(&cap->node); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_del(&cap->node); + }

/* * All current users of cap would have taken a reference to it by diff --git a/drivers/staging/greybus/bootrom.c b/drivers/staging/greybus/bootrom.c index 83921d90c..923456d6c 100644 --- a/drivers/staging/greybus/bootrom.c +++ b/drivers/staging/greybus/bootrom.c @@ -78,9 +78,9 @@ static void gb_bootrom_timedout(struct work_struct *work)

dev_err(dev, "Timed out waiting for %s from the Module\n", reason);

- mutex_lock(&bootrom->mutex); - free_firmware(bootrom); - mutex_unlock(&bootrom->mutex); + scoped_guard(mutex, &bootrom->mutex) { + free_firmware(bootrom); + }

/* TODO: Power-off Module ? */ } @@ -240,6 +240,11 @@ static int gb_bootrom_firmware_size_request(struct gb_operation *op)

static int gb_bootrom_get_firmware(struct gb_operation *op) { + /* + * Keep explicit mutex_lock/unlock here instead of guard(mutex) + * to release the lock before queue_work. + */ + struct gb_bootrom *bootrom = gb_connection_get_data(op->connection); const struct firmware *fw; struct gb_bootrom_get_firmware_request *firmware_request; diff --git a/drivers/staging/greybus/camera.c b/drivers/staging/greybus/camera.c index 62b55bb28..2edb02a75 100644 --- a/drivers/staging/greybus/camera.c +++ b/drivers/staging/greybus/camera.c @@ -490,24 +490,21 @@ static int gb_camera_capabilities(struct gb_camera *gcam, if (ret) return ret;

- mutex_lock(&gcam->mutex); + scoped_guard(mutex, &gcam->mutex) { + if (!gcam->connection) { + ret = -EINVAL; + goto done; + }

- if (!gcam->connection) { - ret = -EINVAL; - goto done; + ret = gb_camera_operation_sync_flags(gcam->connection, + GB_CAMERA_TYPE_CAPABILITIES, + GB_OPERATION_FLAG_SHORT_RESPONSE, + NULL, 0, + (void *)capabilities, size); + if (ret) + dev_err(&gcam->bundle->dev, "failed to retrieve capabilities: %d\n", ret); } - - ret = gb_camera_operation_sync_flags(gcam->connection, - GB_CAMERA_TYPE_CAPABILITIES, - GB_OPERATION_FLAG_SHORT_RESPONSE, - NULL, 0, - (void *)capabilities, size); - if (ret) - dev_err(&gcam->bundle->dev, "failed to retrieve capabilities: %d\n", ret); - done: - mutex_unlock(&gcam->mutex); - gb_pm_runtime_put_autosuspend(gcam->bundle);

return ret; @@ -519,6 +516,11 @@ static int gb_camera_configure_streams(struct gb_camera *gcam, struct gb_camera_stream_config *streams, struct gb_camera_csi_params *csi_params) { + /* + * Keep explicit mutex_lock/unlock here instead of guard(mutex) + * to release the lock before freeing req and resp. + */ + struct gb_camera_configure_streams_request *req; struct gb_camera_configure_streams_response *resp; unsigned int nstreams = *num_streams; @@ -668,18 +670,17 @@ static int gb_camera_capture(struct gb_camera *gcam, u32 request_id, req->num_frames = cpu_to_le16(num_frames); memcpy(req->settings, settings, settings_size);

- mutex_lock(&gcam->mutex); + scoped_guard(mutex, &gcam->mutex) { + if (!gcam->connection) { + ret = -EINVAL; + goto done; + }

- if (!gcam->connection) { - ret = -EINVAL; - goto done; + ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE, + req, req_size, NULL, 0); }

- ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE, - req, req_size, NULL, 0); done: - mutex_unlock(&gcam->mutex); - kfree(req);

return ret; @@ -690,25 +691,21 @@ static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id) struct gb_camera_flush_response resp; int ret;

- mutex_lock(&gcam->mutex); + guard(mutex)(&gcam->mutex);

if (!gcam->connection) { - ret = -EINVAL; - goto done; + return -EINVAL; }

ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0, &resp, sizeof(resp));

if (ret < 0) - goto done; + return ret;

if (request_id) *request_id = le32_to_cpu(resp.request_id);

-done: - mutex_unlock(&gcam->mutex); - return ret; }

@@ -1187,7 +1184,7 @@ static void gb_camera_cleanup(struct gb_camera *gcam) { gb_camera_debugfs_cleanup(gcam);

- mutex_lock(&gcam->mutex); + guard(mutex)(&gcam->mutex); if (gcam->data_connection) { gb_connection_disable(gcam->data_connection); gb_connection_destroy(gcam->data_connection); @@ -1199,7 +1196,6 @@ static void gb_camera_cleanup(struct gb_camera *gcam) gb_connection_destroy(gcam->connection); gcam->connection = NULL; } - mutex_unlock(&gcam->mutex); }

static void gb_camera_release_module(struct kref *ref) diff --git a/drivers/staging/greybus/fw-download.c b/drivers/staging/greybus/fw-download.c index a0a683447..a4e2e2361 100644 --- a/drivers/staging/greybus/fw-download.c +++ b/drivers/staging/greybus/fw-download.c @@ -93,21 +93,16 @@ static struct fw_request *get_fw_req(struct fw_download *fw_download, { struct fw_request *fw_req;

- mutex_lock(&fw_download->mutex); + guard(mutex)(&fw_download->mutex);

list_for_each_entry(fw_req, &fw_download->fw_requests, node) { if (fw_req->firmware_id == firmware_id) { kref_get(&fw_req->kref); - goto unlock; + return fw_req; } }

- fw_req = NULL; - -unlock: - mutex_unlock(&fw_download->mutex); - - return fw_req; + return NULL; }

static void free_firmware(struct fw_download *fw_download, @@ -117,9 +112,9 @@ static void free_firmware(struct fw_download *fw_download, if (fw_req->disabled) return;

- mutex_lock(&fw_download->mutex); - list_del(&fw_req->node); - mutex_unlock(&fw_download->mutex); + scoped_guard(mutex, &fw_download->mutex) { + list_del(&fw_req->node); + }

fw_req->disabled = true; put_fw_req(fw_req); @@ -197,9 +192,9 @@ static struct fw_request *find_firmware(struct fw_download *fw_download, fw_req->fw_download = fw_download; kref_init(&fw_req->kref);

- mutex_lock(&fw_download->mutex); - list_add(&fw_req->node, &fw_download->fw_requests); - mutex_unlock(&fw_download->mutex); + scoped_guard(mutex, &fw_download->mutex) { + list_add(&fw_req->node, &fw_download->fw_requests); + }

/* Timeout, in jiffies, within which firmware should get loaded */ req_count = DIV_ROUND_UP(fw_req->fw->size, MIN_FETCH_SIZE); @@ -448,10 +443,10 @@ void gb_fw_download_connection_exit(struct gb_connection *connection) * Make sure we have a reference to the pending requests, before they * are freed from the timeout handler. */ - mutex_lock(&fw_download->mutex); - list_for_each_entry(fw_req, &fw_download->fw_requests, node) - kref_get(&fw_req->kref); - mutex_unlock(&fw_download->mutex); + scoped_guard(mutex, &fw_download->mutex) { + list_for_each_entry(fw_req, &fw_download->fw_requests, node) + kref_get(&fw_req->kref); + }

/* Release pending firmware packages */ list_for_each_entry_safe(fw_req, tmp, &fw_download->fw_requests, node) { diff --git a/drivers/staging/greybus/fw-management.c b/drivers/staging/greybus/fw-management.c index 5d01da6b6..c48bea217 100644 --- a/drivers/staging/greybus/fw-management.c +++ b/drivers/staging/greybus/fw-management.c @@ -87,21 +87,16 @@ static struct fw_mgmt *get_fw_mgmt(struct cdev *cdev) { struct fw_mgmt *fw_mgmt;

- mutex_lock(&list_mutex); + guard(mutex)(&list_mutex);

list_for_each_entry(fw_mgmt, &fw_mgmt_list, node) { if (&fw_mgmt->cdev == cdev) { kref_get(&fw_mgmt->kref); - goto unlock; + return fw_mgmt; } }

- fw_mgmt = NULL; - -unlock: - mutex_unlock(&list_mutex); - - return fw_mgmt; + return NULL; }

static int fw_mgmt_interface_fw_version_operation(struct fw_mgmt *fw_mgmt, @@ -533,7 +528,7 @@ static long fw_mgmt_ioctl_unlocked(struct file *file, unsigned int cmd, * the connection is getting disconnected, so that we don't start any * new operations. */ - mutex_lock(&fw_mgmt->mutex); + guard(mutex)(&fw_mgmt->mutex); if (!fw_mgmt->disabled) { ret = gb_pm_runtime_get_sync(bundle); if (!ret) { @@ -541,7 +536,6 @@ static long fw_mgmt_ioctl_unlocked(struct file *file, unsigned int cmd, gb_pm_runtime_put_autosuspend(bundle); } } - mutex_unlock(&fw_mgmt->mutex);

return ret; } @@ -591,9 +585,9 @@ int gb_fw_mgmt_connection_init(struct gb_connection *connection) mutex_init(&fw_mgmt->mutex); kref_init(&fw_mgmt->kref);

- mutex_lock(&list_mutex); - list_add(&fw_mgmt->node, &fw_mgmt_list); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_add(&fw_mgmt->node, &fw_mgmt_list); + }

ret = gb_connection_enable(connection); if (ret) @@ -631,9 +625,9 @@ int gb_fw_mgmt_connection_init(struct gb_connection *connection) err_connection_disable: gb_connection_disable(connection); err_list_del: - mutex_lock(&list_mutex); - list_del(&fw_mgmt->node); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_del(&fw_mgmt->node); + }

put_fw_mgmt(fw_mgmt);

@@ -657,17 +651,17 @@ void gb_fw_mgmt_connection_exit(struct gb_connection *connection) * Disallow any new ioctl operations on the char device and wait for * existing ones to finish. */ - mutex_lock(&fw_mgmt->mutex); - fw_mgmt->disabled = true; - mutex_unlock(&fw_mgmt->mutex); + scoped_guard(mutex, &fw_mgmt->mutex) { + fw_mgmt->disabled = true; + }

/* All pending greybus operations should have finished by now */ gb_connection_disable(fw_mgmt->connection);

/* Disallow new users to get access to the fw_mgmt structure */ - mutex_lock(&list_mutex); - list_del(&fw_mgmt->node); - mutex_unlock(&list_mutex); + scoped_guard(mutex, &list_mutex) { + list_del(&fw_mgmt->node); + }

/* * All current users of fw_mgmt would have taken a reference to it by diff --git a/drivers/staging/greybus/light.c b/drivers/staging/greybus/light.c index cab02b5da..83df32aa2 100644 --- a/drivers/staging/greybus/light.c +++ b/drivers/staging/greybus/light.c @@ -354,10 +354,10 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel) bool old_active; int ret;

- mutex_lock(&channel->lock); + guard(mutex)(&channel->lock); ret = gb_pm_runtime_get_sync(bundle); if (ret < 0) - goto out_unlock; + return ret;

old_active = channel->active;

@@ -377,7 +377,7 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel)

/* we need to keep module alive when turning to active state */ if (!old_active && channel->active) - goto out_unlock; + return ret;

/* * on the other hand if going to inactive we still hold a reference and @@ -388,8 +388,6 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel)

out_pm_put: gb_pm_runtime_put_autosuspend(bundle); -out_unlock: - mutex_unlock(&channel->lock);

return ret; } @@ -443,10 +441,10 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on, if (!delay_on || !delay_off) return -EINVAL;

- mutex_lock(&channel->lock); + guard(mutex)(&channel->lock); ret = gb_pm_runtime_get_sync(bundle); if (ret < 0) - goto out_unlock; + return ret;

old_active = channel->active;

@@ -467,7 +465,7 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on,

/* we need to keep module alive when turning to active state */ if (!old_active && channel->active) - goto out_unlock; + return ret;

/* * on the other hand if going to inactive we still hold a reference and @@ -478,8 +476,6 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on,

out_pm_put: gb_pm_runtime_put_autosuspend(bundle); -out_unlock: - mutex_unlock(&channel->lock);

return ret; } @@ -1146,15 +1142,14 @@ static int gb_lights_create_all(struct gb_lights *glights) int ret; int i;

- mutex_lock(&glights->lights_lock); + guard(mutex)(&glights->lights_lock); ret = gb_lights_get_count(glights); if (ret < 0) - goto out; + return ret;

glights->lights = kzalloc_objs(struct gb_light, glights->lights_count); if (!glights->lights) { - ret = -ENOMEM; - goto out; + return -ENOMEM; }

for (i = 0; i < glights->lights_count; i++) { @@ -1162,12 +1157,10 @@ static int gb_lights_create_all(struct gb_lights *glights) if (ret < 0) { dev_err(&connection->bundle->dev, "Fail to configure lights device\n"); - goto out; + return ret; } }

-out: - mutex_unlock(&glights->lights_lock); return ret; }

@@ -1177,7 +1170,7 @@ static int gb_lights_register_all(struct gb_lights *glights) int ret = 0; int i;

- mutex_lock(&glights->lights_lock); + guard(mutex)(&glights->lights_lock); for (i = 0; i < glights->lights_count; i++) { ret = gb_lights_light_register(&glights->lights[i]); if (ret < 0) { @@ -1187,7 +1180,6 @@ static int gb_lights_register_all(struct gb_lights *glights) } }

- mutex_unlock(&glights->lights_lock); return ret; }

@@ -1231,14 +1223,14 @@ static int gb_lights_request_handler(struct gb_operation *op) if (event & GB_LIGHTS_LIGHT_CONFIG) { light = &glights->lights[light_id];

- mutex_lock(&glights->lights_lock); - gb_lights_light_release(light); - ret = gb_lights_light_config(glights, light_id); - if (!ret) - ret = gb_lights_light_register(light); - if (ret < 0) + scoped_guard(mutex, &glights->lights_lock) { gb_lights_light_release(light); - mutex_unlock(&glights->lights_lock); + ret = gb_lights_light_config(glights, light_id); + if (!ret) + ret = gb_lights_light_register(light); + if (ret < 0) + gb_lights_light_release(light); + } }

return ret; diff --git a/drivers/staging/greybus/loopback.c b/drivers/staging/greybus/loopback.c index 2a623fc2e..2ca6d5c5f 100644 --- a/drivers/staging/greybus/loopback.c +++ b/drivers/staging/greybus/loopback.c @@ -406,24 +406,22 @@ static void gb_loopback_async_operation_callback(struct gb_operation *operation) op_async = gb_operation_get_data(operation); gb = op_async->gb;

- mutex_lock(&gb->mutex); + scoped_guard(mutex, &gb->mutex) { + if (!result && op_async->completion) + result = op_async->completion(op_async);

- if (!result && op_async->completion) - result = op_async->completion(op_async); + if (!result) { + gb->elapsed_nsecs = gb_loopback_calc_latency(op_async->ts, te); + } else { + gb->error++; + if (result == -ETIMEDOUT) + gb->requests_timedout++; + }

- if (!result) { - gb->elapsed_nsecs = gb_loopback_calc_latency(op_async->ts, te); - } else { - gb->error++; - if (result == -ETIMEDOUT) - gb->requests_timedout++; + gb->iteration_count++; + gb_loopback_calculate_stats(gb, result); }

- gb->iteration_count++; - gb_loopback_calculate_stats(gb, result); - - mutex_unlock(&gb->mutex); - dev_dbg(&gb->connection->bundle->dev, "complete operation %d\n", operation->id);

@@ -848,7 +846,7 @@ static int gb_loopback_fn(void *data) gb_loopback_async_wait_all(gb);

/* Mark complete unless user-space has poked us */ - mutex_lock(&gb->mutex); + guard(mutex)(&gb->mutex); if (gb->iteration_count == gb->iteration_max) { gb->type = 0; gb->send_count = 0; @@ -859,7 +857,6 @@ static int gb_loopback_fn(void *data) dev_dbg(&bundle->dev, "continuing on with new test set\n"); } - mutex_unlock(&gb->mutex); continue; } size = gb->size; @@ -919,18 +916,16 @@ static int gb_loopback_dbgfs_latency_show_common(struct seq_file *s, int retval;

if (kfifo_len(kfifo) == 0) { - retval = -EAGAIN; - goto done; + return -EAGAIN; }

- mutex_lock(mutex); + guard(mutex)(mutex); retval = kfifo_out(kfifo, &latency, sizeof(latency)); if (retval > 0) { seq_printf(s, "%u", latency); - retval = 0; + return 0; } - mutex_unlock(mutex); -done: + return retval; }

diff --git a/drivers/staging/greybus/power_supply.c b/drivers/staging/greybus/power_supply.c index 44bd8a72f..5df14315f 100644 --- a/drivers/staging/greybus/power_supply.c +++ b/drivers/staging/greybus/power_supply.c @@ -365,7 +365,7 @@ static void gb_power_supply_state_change(struct gb_power_supply *gbpsy, * Check gbpsy->pm_acquired to make sure only one pair of 'get_sync' * and 'put_autosuspend' runtime pm call for state property change. */ - mutex_lock(&gbpsy->supply_lock); + guard(mutex)(&gbpsy->supply_lock);

if ((prop->val == GB_POWER_SUPPLY_STATUS_CHARGING) && !gbpsy->pm_acquired) { @@ -385,8 +385,6 @@ static void gb_power_supply_state_change(struct gb_power_supply *gbpsy, gbpsy->pm_acquired = false; } } - - mutex_unlock(&gbpsy->supply_lock); }

static void check_changed(struct gb_power_supply *gbpsy, @@ -861,11 +859,11 @@ static void _gb_power_supplies_release(struct gb_power_supplies *supplies) if (!supplies->supply) return;

- mutex_lock(&supplies->supplies_lock); - for (i = 0; i < supplies->supplies_count; i++) - _gb_power_supply_release(&supplies->supply[i]); - kfree(supplies->supply); - mutex_unlock(&supplies->supplies_lock); + scoped_guard(mutex, &supplies->supplies_lock) { + for (i = 0; i < supplies->supplies_count; i++) + _gb_power_supply_release(&supplies->supply[i]); + kfree(supplies->supply); + } kfree(supplies); }

@@ -935,18 +933,17 @@ static int gb_power_supplies_setup(struct gb_power_supplies *supplies) int ret; int i;

- mutex_lock(&supplies->supplies_lock); + guard(mutex)(&supplies->supplies_lock);

ret = gb_power_supplies_get_count(supplies); if (ret < 0) - goto out; + return ret;

supplies->supply = kzalloc_objs(struct gb_power_supply, supplies->supplies_count);

if (!supplies->supply) { - ret = -ENOMEM; - goto out; + return -ENOMEM; }

for (i = 0; i < supplies->supplies_count; i++) { @@ -954,11 +951,10 @@ static int gb_power_supplies_setup(struct gb_power_supplies *supplies) if (ret < 0) { dev_err(&connection->bundle->dev, "Fail to configure supplies devices\n"); - goto out; + return ret; } } -out: - mutex_unlock(&supplies->supplies_lock); + return ret; }

@@ -968,7 +964,7 @@ static int gb_power_supplies_register(struct gb_power_supplies *supplies) int ret = 0; int i;

- mutex_lock(&supplies->supplies_lock); + guard(mutex)(&supplies->supplies_lock);

for (i = 0; i < supplies->supplies_count; i++) { ret = gb_power_supply_enable(&supplies->supply[i]); @@ -979,7 +975,6 @@ static int gb_power_supplies_register(struct gb_power_supplies *supplies) } }

- mutex_unlock(&supplies->supplies_lock); return ret; }

@@ -992,7 +987,6 @@ static int gb_supplies_request_handler(struct gb_operation *op) struct gb_power_supply_event_request *payload; u8 psy_id; u8 event; - int ret = 0;

if (op->type != GB_POWER_SUPPLY_TYPE_EVENT) { dev_err(&connection->bundle->dev, @@ -1011,14 +1005,13 @@ static int gb_supplies_request_handler(struct gb_operation *op)

payload = request->payload; psy_id = payload->psy_id; - mutex_lock(&supplies->supplies_lock); + guard(mutex)(&supplies->supplies_lock); if (psy_id >= supplies->supplies_count || !supplies->supply[psy_id].registered) { dev_err(&connection->bundle->dev, "Event received for unconfigured power_supply id: %d\n", psy_id); - ret = -EINVAL; - goto out_unlock; + return -EINVAL; }

event = payload->event; @@ -1028,8 +1021,7 @@ static int gb_supplies_request_handler(struct gb_operation *op) */ gbpsy = &supplies->supply[psy_id]; if (!gbpsy->update_interval) { - ret = -ESHUTDOWN; - goto out_unlock; + return -ESHUTDOWN; }

if (event & GB_POWER_SUPPLY_UPDATE) { @@ -1042,9 +1034,7 @@ static int gb_supplies_request_handler(struct gb_operation *op) gb_power_supply_status_update(gbpsy); }

-out_unlock: - mutex_unlock(&supplies->supplies_lock); - return ret; + return 0; }

static int gb_power_supply_probe(struct gb_bundle *bundle, diff --git a/drivers/staging/greybus/raw.c b/drivers/staging/greybus/raw.c index 4f1b3f4db..b280b5b75 100644 --- a/drivers/staging/greybus/raw.c +++ b/drivers/staging/greybus/raw.c @@ -246,12 +246,12 @@ static void gb_raw_disconnect(struct gb_bundle *bundle) gb_connection_disable(connection); gb_connection_destroy(connection);

- mutex_lock(&raw->list_lock); - list_for_each_entry_safe(raw_data, temp, &raw->list, entry) { - list_del(&raw_data->entry); - kfree(raw_data); + scoped_guard(mutex, &raw->list_lock) { + list_for_each_entry_safe(raw_data, temp, &raw->list, entry) { + list_del(&raw_data->entry); + kfree(raw_data); + } } - mutex_unlock(&raw->list_lock); put_device(&raw->dev); }

@@ -310,19 +310,16 @@ static ssize_t raw_read(struct file *file, char __user *buf, size_t count, int retval = 0; struct raw_data *raw_data;

- mutex_lock(&raw->list_lock); + guard(mutex)(&raw->list_lock); if (list_empty(&raw->list)) - goto exit; + return 0;

raw_data = list_first_entry(&raw->list, struct raw_data, entry); - if (raw_data->len > count) { - retval = -ENOSPC; - goto exit; - } + if (raw_data->len > count) + return -ENOSPC;

if (copy_to_user(buf, &raw_data->data[0], raw_data->len)) { - retval = -EFAULT; - goto exit; + return -EFAULT; }

list_del(&raw_data->entry); @@ -330,8 +327,6 @@ static ssize_t raw_read(struct file *file, char __user *buf, size_t count, retval = raw_data->len; kfree(raw_data);

-exit: - mutex_unlock(&raw->list_lock); return retval; }

diff --git a/drivers/staging/greybus/sdio.c b/drivers/staging/greybus/sdio.c index 3952f3d22..316aaeb15 100644 --- a/drivers/staging/greybus/sdio.c +++ b/drivers/staging/greybus/sdio.c @@ -597,7 +597,7 @@ static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) u8 drv_type; u32 vdd = 0;

- mutex_lock(&host->lock); + guard(mutex)(&host->lock); request.clock = cpu_to_le32(ios->clock);

if (ios->vdd) @@ -710,24 +710,19 @@ static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)

ret = gb_sdio_set_ios(host, &request); if (ret < 0) - goto out; + return;

memcpy(&mmc->ios, ios, sizeof(mmc->ios)); - -out: - mutex_unlock(&host->lock); }

static int gb_mmc_get_ro(struct mmc_host *mmc) { struct gb_sdio_host *host = mmc_priv(mmc);

- mutex_lock(&host->lock); + guard(mutex)(&host->lock); if (host->removed) { - mutex_unlock(&host->lock); return -ESHUTDOWN; } - mutex_unlock(&host->lock);

return host->read_only; } @@ -736,12 +731,10 @@ static int gb_mmc_get_cd(struct mmc_host *mmc) { struct gb_sdio_host *host = mmc_priv(mmc);

- mutex_lock(&host->lock); + guard(mutex)(&host->lock); if (host->removed) { - mutex_unlock(&host->lock); return -ESHUTDOWN; } - mutex_unlock(&host->lock);

return host->card_present; } @@ -852,11 +845,11 @@ static void gb_sdio_remove(struct gbphy_device *gbphy_dev) if (ret) gbphy_runtime_get_noresume(gbphy_dev);

- mutex_lock(&host->lock); - host->removed = true; - mmc = host->mmc; - gb_connection_set_data(connection, NULL); - mutex_unlock(&host->lock); + scoped_guard(mutex, &host->lock) { + host->removed = true; + mmc = host->mmc; + gb_connection_set_data(connection, NULL); + }

destroy_workqueue(host->mrq_workqueue); gb_connection_disable_rx(connection); diff --git a/drivers/staging/greybus/uart.c b/drivers/staging/greybus/uart.c index 24b4dab06..e1aa12966 100644 --- a/drivers/staging/greybus/uart.c +++ b/drivers/staging/greybus/uart.c @@ -341,19 +341,16 @@ static struct gb_tty *get_gb_by_minor(unsigned int minor) { struct gb_tty *gb_tty;

- mutex_lock(&table_lock); + guard(mutex)(&table_lock); gb_tty = idr_find(&tty_minors, minor); if (gb_tty) { - mutex_lock(&gb_tty->mutex); + guard(mutex)(&gb_tty->mutex); if (gb_tty->disconnected) { - mutex_unlock(&gb_tty->mutex); gb_tty = NULL; } else { tty_port_get(&gb_tty->port); - mutex_unlock(&gb_tty->mutex); } } - mutex_unlock(&table_lock); return gb_tty; }

@@ -361,9 +358,9 @@ static int alloc_minor(struct gb_tty *gb_tty) { int minor;

- mutex_lock(&table_lock); - minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL); - mutex_unlock(&table_lock); + scoped_guard(mutex, &table_lock) { + minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL); + } if (minor >= 0) gb_tty->minor = minor; return minor; @@ -374,9 +371,8 @@ static void release_minor(struct gb_tty *gb_tty) int minor = gb_tty->minor;

gb_tty->minor = 0; /* Maybe should use an invalid value instead */ - mutex_lock(&table_lock); + guard(mutex)(&table_lock); idr_remove(&tty_minors, minor); - mutex_unlock(&table_lock); }

static int gb_tty_install(struct tty_driver *driver, struct tty_struct *tty) @@ -596,13 +592,12 @@ static int get_serial_info(struct tty_struct *tty, struct gb_tty *gb_tty = tty->driver_data;

ss->line = gb_tty->minor; - mutex_lock(&gb_tty->port.mutex); + guard(mutex)(&gb_tty->port.mutex); ss->close_delay = jiffies_to_msecs(gb_tty->port.close_delay) / 10; ss->closing_wait = gb_tty->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ? ASYNC_CLOSING_WAIT_NONE : jiffies_to_msecs(gb_tty->port.closing_wait) / 10; - mutex_unlock(&gb_tty->port.mutex);

return 0; } @@ -620,7 +615,7 @@ static int set_serial_info(struct tty_struct *tty, ASYNC_CLOSING_WAIT_NONE : msecs_to_jiffies(ss->closing_wait * 10);

- mutex_lock(&gb_tty->port.mutex); + guard(mutex)(&gb_tty->port.mutex); if (!capable(CAP_SYS_ADMIN)) { if ((close_delay != gb_tty->port.close_delay) || (closing_wait != gb_tty->port.closing_wait)) @@ -629,7 +624,6 @@ static int set_serial_info(struct tty_struct *tty, gb_tty->port.close_delay = close_delay; gb_tty->port.closing_wait = closing_wait; } - mutex_unlock(&gb_tty->port.mutex); return retval; }

@@ -926,11 +920,11 @@ static void gb_uart_remove(struct gbphy_device *gbphy_dev) if (ret) gbphy_runtime_get_noresume(gbphy_dev);

- mutex_lock(&gb_tty->mutex); - gb_tty->disconnected = true; + scoped_guard(mutex, &gb_tty->mutex) { + gb_tty->disconnected = true;

- wake_up_all(&gb_tty->wioctl); - mutex_unlock(&gb_tty->mutex); + wake_up_all(&gb_tty->wioctl); + }

tty_port_tty_vhangup(&gb_tty->port);