Kernel/linux-next
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git synced 2025-01-09 07:23:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ALSA: control: Take power_ref lock primarily

Browse Source 
The code path for kcontrol accesses have often nested locks of both
card's controls_rwsem and power_ref, and applies in that order.
However, what could take much longer is the latter, power_ref; it
waits for the power state of the device, and it pretty much depends on
the user's action.

This patch swaps the locking order of those locks to a more natural
way, namely, power_ref -> controls_rwsem, in order to shorten the time
of possible nested locks.  For consistency, power_ref is taken always
in the top-level caller side (that is, *_user() functions and the
ioctl handler itself).

Link: https://patch.msgid.link/20240729160659.4516-1-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai 2024-07-29 18:06:58 +02:00
parent 3bb668264d
commit fcc62b1910
1 changed files with 34 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
sound/core/control.c
View File

@ -1167,9 +1167,7 @@ static int __snd_ctl_elem_info(struct snd_card *card,
#ifdef CONFIG_SND_DEBUG #ifdef CONFIG_SND_DEBUG
info->access = 0; info->access = 0;
#endif #endif
result = snd_power_ref_and_wait(card); result = kctl->info(kctl, info);
if (!result)
result = kctl->info(kctl, info);
snd_power_unref(card); snd_power_unref(card);
if (result >= 0) { if (result >= 0) {
snd_BUG_ON(info->access); snd_BUG_ON(info->access);
@ -1208,12 +1206,17 @@ static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl, static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl,
struct snd_ctl_elem_info __user *_info) struct snd_ctl_elem_info __user *_info)
{ {
struct snd_card *card = ctl->card;
struct snd_ctl_elem_info info; struct snd_ctl_elem_info info;
int result; int result;
if (copy_from_user(&info, _info, sizeof(info))) if (copy_from_user(&info, _info, sizeof(info)))
return -EFAULT; return -EFAULT;
result = snd_power_ref_and_wait(card);
if (result)
return result;
result = snd_ctl_elem_info(ctl, &info); result = snd_ctl_elem_info(ctl, &info);
snd_power_unref(card);
if (result < 0) if (result < 0)
return result; return result;
/* drop internal access flags */ /* drop internal access flags */
@ -1257,10 +1260,7 @@ static int snd_ctl_elem_read(struct snd_card *card,
if (!snd_ctl_skip_validation(&info)) if (!snd_ctl_skip_validation(&info))
fill_remaining_elem_value(control, &info, pattern); fill_remaining_elem_value(control, &info, pattern);
ret = snd_power_ref_and_wait(card); ret = kctl->get(kctl, control);
if (!ret)
ret = kctl->get(kctl, control);
snd_power_unref(card);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (!snd_ctl_skip_validation(&info) && if (!snd_ctl_skip_validation(&info) &&
@ -1285,7 +1285,11 @@ static int snd_ctl_elem_read_user(struct snd_card *card,
if (IS_ERR(control)) if (IS_ERR(control))
return PTR_ERR(no_free_ptr(control)); return PTR_ERR(no_free_ptr(control));
result = snd_power_ref_and_wait(card);
if (result)
return result;
result = snd_ctl_elem_read(card, control); result = snd_ctl_elem_read(card, control);
snd_power_unref(card);
if (result < 0) if (result < 0)
return result; return result;
@ -1300,7 +1304,7 @@ static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
struct snd_kcontrol *kctl; struct snd_kcontrol *kctl;
struct snd_kcontrol_volatile *vd; struct snd_kcontrol_volatile *vd;
unsigned int index_offset; unsigned int index_offset;
int result; int result = 0;
down_write(&card->controls_rwsem); down_write(&card->controls_rwsem);
kctl = snd_ctl_find_id_locked(card, &control->id); kctl = snd_ctl_find_id_locked(card, &control->id);
@ -1318,9 +1322,8 @@ static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
} }
snd_ctl_build_ioff(&control->id, kctl, index_offset); snd_ctl_build_ioff(&control->id, kctl, index_offset);
result = snd_power_ref_and_wait(card);
/* validate input values */ /* validate input values */
if (IS_ENABLED(CONFIG_SND_CTL_INPUT_VALIDATION) && !result) { if (IS_ENABLED(CONFIG_SND_CTL_INPUT_VALIDATION)) {
struct snd_ctl_elem_info info; struct snd_ctl_elem_info info;
memset(&info, 0, sizeof(info)); memset(&info, 0, sizeof(info));
@ -1332,7 +1335,6 @@ static int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
} }
if (!result) if (!result)
result = kctl->put(kctl, control); result = kctl->put(kctl, control);
snd_power_unref(card);
if (result < 0) { if (result < 0) {
up_write(&card->controls_rwsem); up_write(&card->controls_rwsem);
return result; return result;
@ -1361,7 +1363,11 @@ static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
return PTR_ERR(no_free_ptr(control)); return PTR_ERR(no_free_ptr(control));
card = file->card; card = file->card;
result = snd_power_ref_and_wait(card);
if (result < 0)
return result;
result = snd_ctl_elem_write(card, file, control); result = snd_ctl_elem_write(card, file, control);
snd_power_unref(card);
if (result < 0) if (result < 0)
return result; return result;
@ -1830,7 +1836,7 @@ static int call_tlv_handler(struct snd_ctl_file *file, int op_flag,
{SNDRV_CTL_TLV_OP_CMD, SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND}, {SNDRV_CTL_TLV_OP_CMD, SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND},
}; };
struct snd_kcontrol_volatile *vd = &kctl->vd[snd_ctl_get_ioff(kctl, id)]; struct snd_kcontrol_volatile *vd = &kctl->vd[snd_ctl_get_ioff(kctl, id)];
int i, ret; int i;
/* Check support of the request for this element. */ /* Check support of the request for this element. */
for (i = 0; i < ARRAY_SIZE(pairs); ++i) { for (i = 0; i < ARRAY_SIZE(pairs); ++i) {
@ -1848,11 +1854,7 @@ static int call_tlv_handler(struct snd_ctl_file *file, int op_flag,
vd->owner != NULL && vd->owner != file) vd->owner != NULL && vd->owner != file)
return -EPERM; return -EPERM;
ret = snd_power_ref_and_wait(file->card); return kctl->tlv.c(kctl, op_flag, size, buf);
if (!ret)
ret = kctl->tlv.c(kctl, op_flag, size, buf);
snd_power_unref(file->card);
return ret;
} }
static int read_tlv_buf(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id, static int read_tlv_buf(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id,
@ -1965,16 +1967,28 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg
case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS: case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
return snd_ctl_subscribe_events(ctl, ip); return snd_ctl_subscribe_events(ctl, ip);
case SNDRV_CTL_IOCTL_TLV_READ: case SNDRV_CTL_IOCTL_TLV_READ:
scoped_guard(rwsem_read, &ctl->card->controls_rwsem) err = snd_power_ref_and_wait(card);
if (err < 0)
return err;
scoped_guard(rwsem_read, &card->controls_rwsem)
err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_READ); err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_READ);
snd_power_unref(card);
return err; return err;
case SNDRV_CTL_IOCTL_TLV_WRITE: case SNDRV_CTL_IOCTL_TLV_WRITE:
scoped_guard(rwsem_write, &ctl->card->controls_rwsem) err = snd_power_ref_and_wait(card);
if (err < 0)
return err;
scoped_guard(rwsem_write, &card->controls_rwsem)
err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_WRITE); err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_WRITE);
snd_power_unref(card);
return err; return err;
case SNDRV_CTL_IOCTL_TLV_COMMAND: case SNDRV_CTL_IOCTL_TLV_COMMAND:
scoped_guard(rwsem_write, &ctl->card->controls_rwsem) err = snd_power_ref_and_wait(card);
if (err < 0)
return err;
scoped_guard(rwsem_write, &card->controls_rwsem)
err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_CMD); err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_CMD);
snd_power_unref(card);
return err; return err;
case SNDRV_CTL_IOCTL_POWER: case SNDRV_CTL_IOCTL_POWER:
return -ENOPROTOOPT; return -ENOPROTOOPT;