nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

ALSA: hwdep: Use guard() for locking

Browse source 
We can simplify the code gracefully with new guard() macro and co for
automatic cleanup of locks.

There are still a few remaining explicit mutex_lock/unlock calls, and
those are for the places where we do temporary unlock/relock, which
doesn't fit well with the guard(), so far.

Only the code refactoring, and no functional changes.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Link: https://lore.kernel.org/r/20240227085306.9764-6-tiwai@suse.de
This commit is contained in:
Takashi Iwai 2024-02-27 09:52:47 +01:00
parent b04892691d
commit e6684d08cc
1 changed files with 38 additions and 47 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

85
sound/core/hwdep.c
View file

@ -149,12 +149,12 @@ static int snd_hwdep_release(struct inode *inode, struct file * file)
struct snd_hwdep *hw = file->private_data; struct snd_hwdep *hw = file->private_data;
struct module *mod = hw->card->module; struct module *mod = hw->card->module;
mutex_lock(&hw->open_mutex); scoped_guard(mutex, &hw->open_mutex) {
if (hw->ops.release) if (hw->ops.release)
err = hw->ops.release(hw, file); err = hw->ops.release(hw, file);
if (hw->used > 0) if (hw->used > 0)
hw->used--; hw->used--;
mutex_unlock(&hw->open_mutex); }
wake_up(&hw->open_wait); wake_up(&hw->open_wait);
snd_card_file_remove(hw->card, file); snd_card_file_remove(hw->card, file);
@ -272,43 +272,43 @@ static int snd_hwdep_control_ioctl(struct snd_card *card,
if (get_user(device, (int __user *)arg)) if (get_user(device, (int __user *)arg))
return -EFAULT; return -EFAULT;
mutex_lock(&register_mutex);
if (device < 0) scoped_guard(mutex, &register_mutex) {
device = 0; if (device < 0)
else if (device < SNDRV_MINOR_HWDEPS) device = 0;
device++; else if (device < SNDRV_MINOR_HWDEPS)
else device++;
device = SNDRV_MINOR_HWDEPS; else
device = SNDRV_MINOR_HWDEPS;
while (device < SNDRV_MINOR_HWDEPS) { while (device < SNDRV_MINOR_HWDEPS) {
if (snd_hwdep_search(card, device)) if (snd_hwdep_search(card, device))
break; break;
device++; device++;
}
if (device >= SNDRV_MINOR_HWDEPS)
device = -1;
if (put_user(device, (int __user *)arg))
return -EFAULT;
return 0;
} }
if (device >= SNDRV_MINOR_HWDEPS) break;
device = -1;
mutex_unlock(&register_mutex);
if (put_user(device, (int __user *)arg))
return -EFAULT;
return 0;
} }
case SNDRV_CTL_IOCTL_HWDEP_INFO: case SNDRV_CTL_IOCTL_HWDEP_INFO:
{ {
struct snd_hwdep_info __user *info = (struct snd_hwdep_info __user *)arg; struct snd_hwdep_info __user *info = (struct snd_hwdep_info __user *)arg;
int device, err; int device;
struct snd_hwdep *hwdep; struct snd_hwdep *hwdep;
if (get_user(device, &info->device)) if (get_user(device, &info->device))
return -EFAULT; return -EFAULT;
mutex_lock(&register_mutex); scoped_guard(mutex, &register_mutex) {
hwdep = snd_hwdep_search(card, device); hwdep = snd_hwdep_search(card, device);
if (hwdep) if (!hwdep)
err = snd_hwdep_info(hwdep, info); return -ENXIO;
else return snd_hwdep_info(hwdep, info);
err = -ENXIO; }
mutex_unlock(&register_mutex); break;
return err;
} }
} }
return -ENOIOCTLCMD; return -ENOIOCTLCMD;
@ -422,11 +422,9 @@ static int snd_hwdep_dev_register(struct snd_device *device)
struct snd_card *card = hwdep->card; struct snd_card *card = hwdep->card;
int err; int err;
mutex_lock(&register_mutex); guard(mutex)(&register_mutex);
if (snd_hwdep_search(card, hwdep->device)) { if (snd_hwdep_search(card, hwdep->device))
mutex_unlock(&register_mutex);
return -EBUSY; return -EBUSY;
}
list_add_tail(&hwdep->list, &snd_hwdep_devices); list_add_tail(&hwdep->list, &snd_hwdep_devices);
err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP, err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP,
hwdep->card, hwdep->device, hwdep->card, hwdep->device,
@ -434,7 +432,6 @@ static int snd_hwdep_dev_register(struct snd_device *device)
if (err < 0) { if (err < 0) {
dev_err(hwdep->dev, "unable to register\n"); dev_err(hwdep->dev, "unable to register\n");
list_del(&hwdep->list); list_del(&hwdep->list);
mutex_unlock(&register_mutex);
return err; return err;
} }
@ -454,7 +451,6 @@ static int snd_hwdep_dev_register(struct snd_device *device)
hwdep->ossreg = 1; hwdep->ossreg = 1;
} }
#endif #endif
mutex_unlock(&register_mutex);
return 0; return 0;
} }
@ -464,12 +460,10 @@ static int snd_hwdep_dev_disconnect(struct snd_device *device)
if (snd_BUG_ON(!hwdep)) if (snd_BUG_ON(!hwdep))
return -ENXIO; return -ENXIO;
mutex_lock(&register_mutex); guard(mutex)(&register_mutex);
if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep) { if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep)
mutex_unlock(&register_mutex);
return -EINVAL; return -EINVAL;
} guard(mutex)(&hwdep->open_mutex);
mutex_lock(&hwdep->open_mutex);
wake_up(&hwdep->open_wait); wake_up(&hwdep->open_wait);
#ifdef CONFIG_SND_OSSEMUL #ifdef CONFIG_SND_OSSEMUL
if (hwdep->ossreg) if (hwdep->ossreg)
@ -477,8 +471,6 @@ static int snd_hwdep_dev_disconnect(struct snd_device *device)
#endif #endif
snd_unregister_device(hwdep->dev); snd_unregister_device(hwdep->dev);
list_del_init(&hwdep->list); list_del_init(&hwdep->list);
mutex_unlock(&hwdep->open_mutex);
mutex_unlock(&register_mutex);
return 0; return 0;
} }
@ -492,11 +484,10 @@ static void snd_hwdep_proc_read(struct snd_info_entry *entry,
{ {
struct snd_hwdep *hwdep; struct snd_hwdep *hwdep;
mutex_lock(&register_mutex); guard(mutex)(&register_mutex);
list_for_each_entry(hwdep, &snd_hwdep_devices, list) list_for_each_entry(hwdep, &snd_hwdep_devices, list)
snd_iprintf(buffer, "%02i-%02i: %s\n", snd_iprintf(buffer, "%02i-%02i: %s\n",
hwdep->card->number, hwdep->device, hwdep->name); hwdep->card->number, hwdep->device, hwdep->name);
mutex_unlock(&register_mutex);
} }
static struct snd_info_entry *snd_hwdep_proc_entry; static struct snd_info_entry *snd_hwdep_proc_entry;