Skip to content

L
linux
Commit 4adb7bcb authored by Takashi Iwai's avatar Takashi Iwai
Browse files
Options

ALSA: core: Use seq_file for text proc file reads 

seq_file is _the_ standard interface for simple text proc files.
Though, we still need to support the binary proc files and the text
file write, and also we need to manage the device disconnection
gracefully.  Thus this patch just replaces the text file read code
with seq_file while keeping the rest intact.

snd_iprintf() helper function is now a macro to expand itself to
seq_printf() to be compatible with the existing code.  The seq_file
object is stored to the unused entry->rbuffer->buffer pointer.

When the output size is expected to be large (greater than PAGE_SIZE),
the driver should set entry->size field beforehand.  Then the given
size will be preallocated and the multiple show calls can be avoided.
Acked-by: default avatarJaroslav Kysela <perex@perex.cz>
Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent 412b979c
Hide whitespace changes
Inline Side-by-side
Showing with 261 additions and 324 deletions
include/sound/info.h
View file @ 4adb7bcb
...@@ -23,6 +23,7 @@ ...@@ -23,6 +23,7 @@
*/ */
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/seq_file.h>
/* buffer for information */ /* buffer for information */
struct snd_info_buffer { struct snd_info_buffer {
...@@ -110,8 +111,18 @@ void snd_card_info_read_oss(struct snd_info_buffer *buffer); ...@@ -110,8 +111,18 @@ void snd_card_info_read_oss(struct snd_info_buffer *buffer);
static inline void snd_card_info_read_oss(struct snd_info_buffer *buffer) {} static inline void snd_card_info_read_oss(struct snd_info_buffer *buffer) {}
#endif #endif
__printf(2, 3) /**
int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...); * snd_iprintf - printf on the procfs buffer
* @buf: the procfs buffer
* @fmt: the printf format
*
* Outputs the string on the procfs buffer just like printf().
*
* Return: zero for success, or a negative error code.
*/
#define snd_iprintf(buf, fmt, args...) \
seq_printf((struct seq_file *)(buf)->buffer, fmt, ##args)
int snd_info_init(void); int snd_info_init(void);
int snd_info_done(void); int snd_info_done(void);
...@@ -175,7 +186,6 @@ static inline int snd_card_proc_new(struct snd_card *card, const char *name, ...@@ -175,7 +186,6 @@ static inline int snd_card_proc_new(struct snd_card *card, const char *name,
static inline void snd_info_set_text_ops(struct snd_info_entry *entry __attribute__((unused)), static inline void snd_info_set_text_ops(struct snd_info_entry *entry __attribute__((unused)),
void *private_data, void *private_data,
void (*read)(struct snd_info_entry *, struct snd_info_buffer *)) {} void (*read)(struct snd_info_entry *, struct snd_info_buffer *)) {}
static inline int snd_info_check_reserved_words(const char *str) { return 1; } static inline int snd_info_check_reserved_words(const char *str) { return 1; }
#endif #endif
......
sound/core/info.c
View file @ 4adb7bcb
...@@ -81,66 +81,6 @@ static int snd_info_version_init(void); ...@@ -81,66 +81,6 @@ static int snd_info_version_init(void);
static int snd_info_version_done(void); static int snd_info_version_done(void);
static void snd_info_disconnect(struct snd_info_entry *entry); static void snd_info_disconnect(struct snd_info_entry *entry);
/* resize the proc r/w buffer */
static int resize_info_buffer(struct snd_info_buffer *buffer,
unsigned int nsize)
{
char *nbuf;
nsize = PAGE_ALIGN(nsize);
nbuf = krealloc(buffer->buffer, nsize, GFP_KERNEL | __GFP_ZERO);
if (! nbuf)
return -ENOMEM;
buffer->buffer = nbuf;
buffer->len = nsize;
return 0;
}
/**
* snd_iprintf - printf on the procfs buffer
* @buffer: the procfs buffer
* @fmt: the printf format
*
* Outputs the string on the procfs buffer just like printf().
*
* Return: The size of output string, or a negative error code.
*/
int snd_iprintf(struct snd_info_buffer *buffer, const char *fmt, ...)
{
va_list args;
int len, res;
int err = 0;
might_sleep();
if (buffer->stop || buffer->error)
return 0;
len = buffer->len - buffer->size;
va_start(args, fmt);
for (;;) {
va_list ap;
va_copy(ap, args);
res = vsnprintf(buffer->buffer + buffer->curr, len, fmt, ap);
va_end(ap);
if (res < len)
break;
err = resize_info_buffer(buffer, buffer->len + PAGE_SIZE);
if (err < 0)
break;
len = buffer->len - buffer->size;
}
va_end(args);
if (err < 0)
return err;
buffer->curr += res;
buffer->size += res;
return res;
}
EXPORT_SYMBOL(snd_iprintf);
/* /*
*/ */
...@@ -153,6 +93,37 @@ EXPORT_SYMBOL(snd_seq_root); ...@@ -153,6 +93,37 @@ EXPORT_SYMBOL(snd_seq_root);
struct snd_info_entry *snd_oss_root; struct snd_info_entry *snd_oss_root;
#endif #endif
static int alloc_info_private(struct snd_info_entry *entry,
struct snd_info_private_data **ret)
{
struct snd_info_private_data *data;
if (!entry || !entry->p)
return -ENODEV;
if (!try_module_get(entry->module))
return -EFAULT;
data = kzalloc(sizeof(*data), GFP_KERNEL);
if (!data) {
module_put(entry->module);
return -ENOMEM;
}
data->entry = entry;
*ret = data;
return 0;
}
static bool valid_pos(loff_t pos, size_t count)
{
if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
return false;
if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos)
return false;
return true;
}
/*
* file ops for binary proc files
*/
static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig) static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig)
{ {
struct snd_info_private_data *data; struct snd_info_private_data *data;
...@@ -162,17 +133,14 @@ static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig) ...@@ -162,17 +133,14 @@ static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig)
data = file->private_data; data = file->private_data;
entry = data->entry; entry = data->entry;
mutex_lock(&entry->access); mutex_lock(&entry->access);
if (entry->content == SNDRV_INFO_CONTENT_DATA && if (entry->c.ops->llseek) {
entry->c.ops->llseek) {
offset = entry->c.ops->llseek(entry, offset = entry->c.ops->llseek(entry,
data->file_private_data, data->file_private_data,
file, offset, orig); file, offset, orig);
goto out; goto out;
} }
if (entry->content == SNDRV_INFO_CONTENT_DATA)
size = entry->size; size = entry->size;
else
size = 0;
switch (orig) { switch (orig) {
case SEEK_SET: case SEEK_SET:
break; break;
...@@ -201,45 +169,20 @@ static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig) ...@@ -201,45 +169,20 @@ static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig)
static ssize_t snd_info_entry_read(struct file *file, char __user *buffer, static ssize_t snd_info_entry_read(struct file *file, char __user *buffer,
size_t count, loff_t * offset) size_t count, loff_t * offset)
{ {
struct snd_info_private_data *data; struct snd_info_private_data *data = file->private_data;
struct snd_info_entry *entry; struct snd_info_entry *entry = data->entry;
struct snd_info_buffer *buf; size_t size;
size_t size = 0;
loff_t pos; loff_t pos;
data = file->private_data;
if (snd_BUG_ON(!data))
return -ENXIO;
pos = *offset; pos = *offset;
if (pos < 0 || (long) pos != pos || (ssize_t) count < 0) if (!valid_pos(pos, count))
return -EIO;
if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos)
return -EIO; return -EIO;
entry = data->entry; if (pos >= entry->size)
switch (entry->content) { return 0;
case SNDRV_INFO_CONTENT_TEXT: size = entry->size - pos;
buf = data->rbuffer; size = min(count, size);
if (buf == NULL) size = entry->c.ops->read(entry, data->file_private_data,
return -EIO; file, buffer, size, pos);
if (pos >= buf->size)
return 0;
size = buf->size - pos;
size = min(count, size);
if (copy_to_user(buffer, buf->buffer + pos, size))
return -EFAULT;
break;
case SNDRV_INFO_CONTENT_DATA:
if (pos >= entry->size)
return 0;
if (entry->c.ops->read) {
size = entry->size - pos;
size = min(count, size);
size = entry->c.ops->read(entry,
data->file_private_data,
file, buffer, size, pos);
}
break;
}
if ((ssize_t) size > 0) if ((ssize_t) size > 0)
*offset = pos + size; *offset = pos + size;
return size; return size;
...@@ -248,280 +191,259 @@ static ssize_t snd_info_entry_read(struct file *file, char __user *buffer, ...@@ -248,280 +191,259 @@ static ssize_t snd_info_entry_read(struct file *file, char __user *buffer,
static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer, static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer,
size_t count, loff_t * offset) size_t count, loff_t * offset)
{ {
struct snd_info_private_data *data; struct snd_info_private_data *data = file->private_data;
struct snd_info_entry *entry; struct snd_info_entry *entry = data->entry;
struct snd_info_buffer *buf;
ssize_t size = 0; ssize_t size = 0;
loff_t pos; loff_t pos;
data = file->private_data;
if (snd_BUG_ON(!data))
return -ENXIO;
entry = data->entry;
pos = *offset; pos = *offset;
if (pos < 0 || (long) pos != pos || (ssize_t) count < 0) if (!valid_pos(pos, count))
return -EIO; return -EIO;
if ((unsigned long) pos + (unsigned long) count < (unsigned long) pos) if (count > 0) {
return -EIO; size_t maxsize = entry->size - pos;
switch (entry->content) { count = min(count, maxsize);
case SNDRV_INFO_CONTENT_TEXT: size = entry->c.ops->write(entry, data->file_private_data,
buf = data->wbuffer; file, buffer, count, pos);
if (buf == NULL)
return -EIO;
mutex_lock(&entry->access);
if (pos + count >= buf->len) {
if (resize_info_buffer(buf, pos + count)) {
mutex_unlock(&entry->access);
return -ENOMEM;
}
}
if (copy_from_user(buf->buffer + pos, buffer, count)) {
mutex_unlock(&entry->access);
return -EFAULT;
}
buf->size = pos + count;
mutex_unlock(&entry->access);
size = count;
break;
case SNDRV_INFO_CONTENT_DATA:
if (entry->c.ops->write && count > 0) {
size_t maxsize = entry->size - pos;
count = min(count, maxsize);
size = entry->c.ops->write(entry,
data->file_private_data,
file, buffer, count, pos);
}
break;
} }
if ((ssize_t) size > 0) if (size > 0)
*offset = pos + size; *offset = pos + size;
return size; return size;
} }
static int snd_info_entry_open(struct inode *inode, struct file *file) static unsigned int snd_info_entry_poll(struct file *file, poll_table *wait)
{
struct snd_info_private_data *data = file->private_data;
struct snd_info_entry *entry = data->entry;
unsigned int mask = 0;
if (entry->c.ops->poll)
return entry->c.ops->poll(entry,
data->file_private_data,
file, wait);
if (entry->c.ops->read)
mask |= POLLIN | POLLRDNORM;
if (entry->c.ops->write)
mask |= POLLOUT | POLLWRNORM;
return mask;
}
static long snd_info_entry_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
struct snd_info_private_data *data = file->private_data;
struct snd_info_entry *entry = data->entry;
if (!entry->c.ops->ioctl)
return -ENOTTY;
return entry->c.ops->ioctl(entry, data->file_private_data,
file, cmd, arg);
}
static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma)
{ {
struct inode *inode = file_inode(file);
struct snd_info_private_data *data;
struct snd_info_entry *entry; struct snd_info_entry *entry;
data = file->private_data;
if (data == NULL)
return 0;
entry = data->entry;
if (!entry->c.ops->mmap)
return -ENXIO;
return entry->c.ops->mmap(entry, data->file_private_data,
inode, file, vma);
}
static int snd_info_entry_open(struct inode *inode, struct file *file)
{
struct snd_info_entry *entry = PDE_DATA(inode);
struct snd_info_private_data *data; struct snd_info_private_data *data;
struct snd_info_buffer *buffer;
int mode, err; int mode, err;
mutex_lock(&info_mutex); mutex_lock(&info_mutex);
entry = PDE_DATA(inode); err = alloc_info_private(entry, &data);
if (entry == NULL || ! entry->p) { if (err < 0)
mutex_unlock(&info_mutex); goto unlock;
return -ENODEV;
}
if (!try_module_get(entry->module)) {
err = -EFAULT;
goto __error1;
}
mode = file->f_flags & O_ACCMODE; mode = file->f_flags & O_ACCMODE;
if (mode == O_RDONLY || mode == O_RDWR) { if (((mode == O_RDONLY || mode == O_RDWR) && !entry->c.ops->read) ||
if ((entry->content == SNDRV_INFO_CONTENT_DATA && ((mode == O_WRONLY || mode == O_RDWR) && !entry->c.ops->write)) {
entry->c.ops->read == NULL)) { err = -ENODEV;
err = -ENODEV; goto error;
goto __error;
}
}
if (mode == O_WRONLY || mode == O_RDWR) {
if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
entry->c.ops->write == NULL)) {
err = -ENODEV;
goto __error;
}
} }
data = kzalloc(sizeof(*data), GFP_KERNEL);
if (data == NULL) { if (entry->c.ops->open) {
err = -ENOMEM; err = entry->c.ops->open(entry, mode, &data->file_private_data);
goto __error; if (err < 0)
} goto error;
data->entry = entry;
switch (entry->content) {
case SNDRV_INFO_CONTENT_TEXT:
if (mode == O_RDONLY || mode == O_RDWR) {
buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
if (buffer == NULL)
goto __nomem;
data->rbuffer = buffer;
buffer->len = PAGE_SIZE;
buffer->buffer = kzalloc(buffer->len, GFP_KERNEL);
if (buffer->buffer == NULL)
goto __nomem;
}
if (mode == O_WRONLY || mode == O_RDWR) {
buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
if (buffer == NULL)
goto __nomem;
data->wbuffer = buffer;
buffer->len = PAGE_SIZE;
buffer->buffer = kmalloc(buffer->len, GFP_KERNEL);
if (buffer->buffer == NULL)
goto __nomem;
}
break;
case SNDRV_INFO_CONTENT_DATA: /* data */
if (entry->c.ops->open) {
if ((err = entry->c.ops->open(entry, mode,
&data->file_private_data)) < 0) {
kfree(data);
goto __error;
}
}
break;
} }
file->private_data = data; file->private_data = data;
mutex_unlock(&info_mutex); mutex_unlock(&info_mutex);
if (entry->content == SNDRV_INFO_CONTENT_TEXT &&
(mode == O_RDONLY || mode == O_RDWR)) {
if (entry->c.text.read) {
mutex_lock(&entry->access);
entry->c.text.read(entry, data->rbuffer);
mutex_unlock(&entry->access);
}
}
return 0; return 0;
__nomem: error:
if (data->rbuffer) {
kfree(data->rbuffer->buffer);
kfree(data->rbuffer);
}
if (data->wbuffer) {
kfree(data->wbuffer->buffer);
kfree(data->wbuffer);
}
kfree(data); kfree(data);
err = -ENOMEM;
__error:
module_put(entry->module); module_put(entry->module);
__error1: unlock:
mutex_unlock(&info_mutex); mutex_unlock(&info_mutex);
return err; return err;
} }
static int snd_info_entry_release(struct inode *inode, struct file *file) static int snd_info_entry_release(struct inode *inode, struct file *file)
{ {
struct snd_info_entry *entry; struct snd_info_private_data *data = file->private_data;
struct snd_info_private_data *data; struct snd_info_entry *entry = data->entry;
int mode;
mode = file->f_flags & O_ACCMODE; if (entry->c.ops->release)
data = file->private_data; entry->c.ops->release(entry, file->f_flags & O_ACCMODE,
entry = data->entry; data->file_private_data);
switch (entry->content) {
case SNDRV_INFO_CONTENT_TEXT:
if (data->rbuffer) {
kfree(data->rbuffer->buffer);
kfree(data->rbuffer);
}
if (data->wbuffer) {
if (entry->c.text.write) {
entry->c.text.write(entry, data->wbuffer);
if (data->wbuffer->error) {
if (entry->card)
dev_warn(entry->card->dev, "info: data write error to %s (%i)\n",
entry->name,
data->wbuffer->error);
else
pr_warn("ALSA: info: data write error to %s (%i)\n",
entry->name,
data->wbuffer->error);
}
}
kfree(data->wbuffer->buffer);
kfree(data->wbuffer);
}
break;
case SNDRV_INFO_CONTENT_DATA:
if (entry->c.ops->release)
entry->c.ops->release(entry, mode,
data->file_private_data);
break;
}
module_put(entry->module); module_put(entry->module);
kfree(data); kfree(data);
return 0; return 0;
} }
static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait) static const struct file_operations snd_info_entry_operations =
{ {
struct snd_info_private_data *data; .owner = THIS_MODULE,
struct snd_info_entry *entry; .llseek = snd_info_entry_llseek,
unsigned int mask; .read = snd_info_entry_read,
.write = snd_info_entry_write,
.poll = snd_info_entry_poll,
.unlocked_ioctl = snd_info_entry_ioctl,
.mmap = snd_info_entry_mmap,
.open = snd_info_entry_open,
.release = snd_info_entry_release,
};
data = file->private_data; /*
if (data == NULL) * file ops for text proc files
return 0; */
entry = data->entry; static ssize_t snd_info_text_entry_write(struct file *file,
mask = 0; const char __user *buffer,
switch (entry->content) { size_t count, loff_t *offset)
case SNDRV_INFO_CONTENT_DATA: {
if (entry->c.ops->poll) struct seq_file *m = file->private_data;
return entry->c.ops->poll(entry, struct snd_info_private_data *data = m->private;
data->file_private_data, struct snd_info_entry *entry = data->entry;
file, wait); struct snd_info_buffer *buf;
if (entry->c.ops->read) loff_t pos;
mask |= POLLIN | POLLRDNORM; size_t next;
if (entry->c.ops->write) int err = 0;
mask |= POLLOUT | POLLWRNORM;
break; pos = *offset;
if (!valid_pos(pos, count))
return -EIO;
next = pos + count;
mutex_lock(&entry->access);
buf = data->wbuffer;
if (!buf) {
data->wbuffer = buf = kzalloc(sizeof(*buf), GFP_KERNEL);
if (!buf) {
err = -ENOMEM;
goto error;
}
} }
return mask; if (next > buf->len) {
char *nbuf = krealloc(buf->buffer, PAGE_ALIGN(next),
GFP_KERNEL | __GFP_ZERO);
if (!nbuf) {
err = -ENOMEM;
goto error;
}
buf->buffer = nbuf;
buf->len = PAGE_ALIGN(next);
}
if (copy_from_user(buf->buffer + pos, buffer, count)) {
err = -EFAULT;
goto error;
}
buf->size = next;
error:
mutex_unlock(&entry->access);
if (err < 0)
return err;
*offset = next;
return count;
} }
static long snd_info_entry_ioctl(struct file *file, unsigned int cmd, static int snd_info_seq_show(struct seq_file *seq, void *p)
unsigned long arg)
{ {
struct snd_info_private_data *data; struct snd_info_private_data *data = seq->private;
struct snd_info_entry *entry; struct snd_info_entry *entry = data->entry;
data = file->private_data; if (entry->c.text.read) {
if (data == NULL) data->rbuffer->buffer = (char *)seq; /* XXX hack! */
return 0; entry->c.text.read(entry, data->rbuffer);
entry = data->entry;
switch (entry->content) {
case SNDRV_INFO_CONTENT_DATA:
if (entry->c.ops->ioctl)
return entry->c.ops->ioctl(entry,
data->file_private_data,
file, cmd, arg);
break;
} }
return -ENOTTY; return 0;
} }
static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma) static int snd_info_text_entry_open(struct inode *inode, struct file *file)
{ {
struct inode *inode = file_inode(file); struct snd_info_entry *entry = PDE_DATA(inode);
struct snd_info_private_data *data; struct snd_info_private_data *data;
struct snd_info_entry *entry; int err;
data = file->private_data; mutex_lock(&info_mutex);
if (data == NULL) err = alloc_info_private(entry, &data);
return 0; if (err < 0)
entry = data->entry; goto unlock;
switch (entry->content) {
case SNDRV_INFO_CONTENT_DATA: data->rbuffer = kzalloc(sizeof(*data->rbuffer), GFP_KERNEL);
if (entry->c.ops->mmap) if (!data->rbuffer) {
return entry->c.ops->mmap(entry, err = -ENOMEM;
data->file_private_data, goto error;
inode, file, vma); }
break; if (entry->size)
err = single_open_size(file, snd_info_seq_show, data,
entry->size);
else
err = single_open(file, snd_info_seq_show, data);
if (err < 0)
goto error;
mutex_unlock(&info_mutex);
return 0;
error:
kfree(data->rbuffer);
kfree(data);
module_put(entry->module);
unlock:
mutex_unlock(&info_mutex);
return err;
}
static int snd_info_text_entry_release(struct inode *inode, struct file *file)
{
struct seq_file *m = file->private_data;
struct snd_info_private_data *data = m->private;
struct snd_info_entry *entry = data->entry;
if (data->wbuffer && entry->c.text.write)
entry->c.text.write(entry, data->wbuffer);
single_release(inode, file);
kfree(data->rbuffer);
if (data->wbuffer) {
kfree(data->wbuffer->buffer);
kfree(data->wbuffer);
} }
return -ENXIO;
module_put(entry->module);
kfree(data);
return 0;
} }
static const struct file_operations snd_info_entry_operations = static const struct file_operations snd_info_text_entry_ops =
{ {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.llseek = snd_info_entry_llseek, .open = snd_info_text_entry_open,
.read = snd_info_entry_read, .release = snd_info_text_entry_release,
.write = snd_info_entry_write, .write = snd_info_text_entry_write,
.poll = snd_info_entry_poll, .llseek = seq_lseek,
.unlocked_ioctl = snd_info_entry_ioctl, .read = seq_read,
.mmap = snd_info_entry_mmap,
.open = snd_info_entry_open,
.release = snd_info_entry_release,
}; };
int __init snd_info_init(void) int __init snd_info_init(void)
...@@ -955,8 +877,13 @@ int snd_info_register(struct snd_info_entry * entry) ...@@ -955,8 +877,13 @@ int snd_info_register(struct snd_info_entry * entry)
return -ENOMEM; return -ENOMEM;
} }
} else { } else {
const struct file_operations *ops;
if (entry->content == SNDRV_INFO_CONTENT_DATA)
ops = &snd_info_entry_operations;
else
ops = &snd_info_text_entry_ops;
p = proc_create_data(entry->name, entry->mode, root, p = proc_create_data(entry->name, entry->mode, root,
&snd_info_entry_operations, entry); ops, entry);
if (!p) { if (!p) {
mutex_unlock(&info_mutex); mutex_unlock(&info_mutex);
return -ENOMEM; return -ENOMEM;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7