linux/sound/core/seq/seq_memory.c
<<
>>
Prefs
   1/*
   2 *  ALSA sequencer Memory Manager
   3 *  Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
   4 *                        Jaroslav Kysela <perex@perex.cz>
   5 *                2000 by Takashi Iwai <tiwai@suse.de>
   6 *
   7 *   This program is free software; you can redistribute it and/or modify
   8 *   it under the terms of the GNU General Public License as published by
   9 *   the Free Software Foundation; either version 2 of the License, or
  10 *   (at your option) any later version.
  11 *
  12 *   This program is distributed in the hope that it will be useful,
  13 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 *   GNU General Public License for more details.
  16 *
  17 *   You should have received a copy of the GNU General Public License
  18 *   along with this program; if not, write to the Free Software
  19 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 *
  21 */
  22
  23#include <linux/init.h>
  24#include <linux/slab.h>
  25#include <linux/vmalloc.h>
  26#include <sound/core.h>
  27
  28#include <sound/seq_kernel.h>
  29#include "seq_memory.h"
  30#include "seq_queue.h"
  31#include "seq_info.h"
  32#include "seq_lock.h"
  33
  34static inline int snd_seq_pool_available(struct snd_seq_pool *pool)
  35{
  36        return pool->total_elements - atomic_read(&pool->counter);
  37}
  38
  39static inline int snd_seq_output_ok(struct snd_seq_pool *pool)
  40{
  41        return snd_seq_pool_available(pool) >= pool->room;
  42}
  43
  44/*
  45 * Variable length event:
  46 * The event like sysex uses variable length type.
  47 * The external data may be stored in three different formats.
  48 * 1) kernel space
  49 *    This is the normal case.
  50 *      ext.data.len = length
  51 *      ext.data.ptr = buffer pointer
  52 * 2) user space
  53 *    When an event is generated via read(), the external data is
  54 *    kept in user space until expanded.
  55 *      ext.data.len = length | SNDRV_SEQ_EXT_USRPTR
  56 *      ext.data.ptr = userspace pointer
  57 * 3) chained cells
  58 *    When the variable length event is enqueued (in prioq or fifo),
  59 *    the external data is decomposed to several cells.
  60 *      ext.data.len = length | SNDRV_SEQ_EXT_CHAINED
  61 *      ext.data.ptr = the additiona cell head
  62 *         -> cell.next -> cell.next -> ..
  63 */
  64
  65/*
  66 * exported:
  67 * call dump function to expand external data.
  68 */
  69
  70static int get_var_len(const struct snd_seq_event *event)
  71{
  72        if ((event->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
  73                return -EINVAL;
  74
  75        return event->data.ext.len & ~SNDRV_SEQ_EXT_MASK;
  76}
  77
  78int snd_seq_dump_var_event(const struct snd_seq_event *event,
  79                           snd_seq_dump_func_t func, void *private_data)
  80{
  81        int len, err;
  82        struct snd_seq_event_cell *cell;
  83
  84        if ((len = get_var_len(event)) <= 0)
  85                return len;
  86
  87        if (event->data.ext.len & SNDRV_SEQ_EXT_USRPTR) {
  88                char buf[32];
  89                char __user *curptr = (char __user *)event->data.ext.ptr;
  90                while (len > 0) {
  91                        int size = sizeof(buf);
  92                        if (len < size)
  93                                size = len;
  94                        if (copy_from_user(buf, curptr, size))
  95                                return -EFAULT;
  96                        err = func(private_data, buf, size);
  97                        if (err < 0)
  98                                return err;
  99                        curptr += size;
 100                        len -= size;
 101                }
 102                return 0;
 103        } if (! (event->data.ext.len & SNDRV_SEQ_EXT_CHAINED)) {
 104                return func(private_data, event->data.ext.ptr, len);
 105        }
 106
 107        cell = (struct snd_seq_event_cell *)event->data.ext.ptr;
 108        for (; len > 0 && cell; cell = cell->next) {
 109                int size = sizeof(struct snd_seq_event);
 110                if (len < size)
 111                        size = len;
 112                err = func(private_data, &cell->event, size);
 113                if (err < 0)
 114                        return err;
 115                len -= size;
 116        }
 117        return 0;
 118}
 119
 120EXPORT_SYMBOL(snd_seq_dump_var_event);
 121
 122
 123/*
 124 * exported:
 125 * expand the variable length event to linear buffer space.
 126 */
 127
 128static int seq_copy_in_kernel(char **bufptr, const void *src, int size)
 129{
 130        memcpy(*bufptr, src, size);
 131        *bufptr += size;
 132        return 0;
 133}
 134
 135static int seq_copy_in_user(char __user **bufptr, const void *src, int size)
 136{
 137        if (copy_to_user(*bufptr, src, size))
 138                return -EFAULT;
 139        *bufptr += size;
 140        return 0;
 141}
 142
 143int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char *buf,
 144                             int in_kernel, int size_aligned)
 145{
 146        int len, newlen;
 147        int err;
 148
 149        if ((len = get_var_len(event)) < 0)
 150                return len;
 151        newlen = len;
 152        if (size_aligned > 0)
 153                newlen = roundup(len, size_aligned);
 154        if (count < newlen)
 155                return -EAGAIN;
 156
 157        if (event->data.ext.len & SNDRV_SEQ_EXT_USRPTR) {
 158                if (! in_kernel)
 159                        return -EINVAL;
 160                if (copy_from_user(buf, (void __user *)event->data.ext.ptr, len))
 161                        return -EFAULT;
 162                return newlen;
 163        }
 164        err = snd_seq_dump_var_event(event,
 165                                     in_kernel ? (snd_seq_dump_func_t)seq_copy_in_kernel :
 166                                     (snd_seq_dump_func_t)seq_copy_in_user,
 167                                     &buf);
 168        return err < 0 ? err : newlen;
 169}
 170
 171EXPORT_SYMBOL(snd_seq_expand_var_event);
 172
 173/*
 174 * release this cell, free extended data if available
 175 */
 176
 177static inline void free_cell(struct snd_seq_pool *pool,
 178                             struct snd_seq_event_cell *cell)
 179{
 180        cell->next = pool->free;
 181        pool->free = cell;
 182        atomic_dec(&pool->counter);
 183}
 184
 185void snd_seq_cell_free(struct snd_seq_event_cell * cell)
 186{
 187        unsigned long flags;
 188        struct snd_seq_pool *pool;
 189
 190        if (snd_BUG_ON(!cell))
 191                return;
 192        pool = cell->pool;
 193        if (snd_BUG_ON(!pool))
 194                return;
 195
 196        spin_lock_irqsave(&pool->lock, flags);
 197        free_cell(pool, cell);
 198        if (snd_seq_ev_is_variable(&cell->event)) {
 199                if (cell->event.data.ext.len & SNDRV_SEQ_EXT_CHAINED) {
 200                        struct snd_seq_event_cell *curp, *nextptr;
 201                        curp = cell->event.data.ext.ptr;
 202                        for (; curp; curp = nextptr) {
 203                                nextptr = curp->next;
 204                                curp->next = pool->free;
 205                                free_cell(pool, curp);
 206                        }
 207                }
 208        }
 209        if (waitqueue_active(&pool->output_sleep)) {
 210                /* has enough space now? */
 211                if (snd_seq_output_ok(pool))
 212                        wake_up(&pool->output_sleep);
 213        }
 214        spin_unlock_irqrestore(&pool->lock, flags);
 215}
 216
 217
 218/*
 219 * allocate an event cell.
 220 */
 221static int snd_seq_cell_alloc(struct snd_seq_pool *pool,
 222                              struct snd_seq_event_cell **cellp,
 223                              int nonblock, struct file *file)
 224{
 225        struct snd_seq_event_cell *cell;
 226        unsigned long flags;
 227        int err = -EAGAIN;
 228        wait_queue_t wait;
 229
 230        if (pool == NULL)
 231                return -EINVAL;
 232
 233        *cellp = NULL;
 234
 235        init_waitqueue_entry(&wait, current);
 236        spin_lock_irqsave(&pool->lock, flags);
 237        if (pool->ptr == NULL) {        /* not initialized */
 238                snd_printd("seq: pool is not initialized\n");
 239                err = -EINVAL;
 240                goto __error;
 241        }
 242        while (pool->free == NULL && ! nonblock && ! pool->closing) {
 243
 244                set_current_state(TASK_INTERRUPTIBLE);
 245                add_wait_queue(&pool->output_sleep, &wait);
 246                spin_unlock_irq(&pool->lock);
 247                schedule();
 248                spin_lock_irq(&pool->lock);
 249                remove_wait_queue(&pool->output_sleep, &wait);
 250                /* interrupted? */
 251                if (signal_pending(current)) {
 252                        err = -ERESTARTSYS;
 253                        goto __error;
 254                }
 255        }
 256        if (pool->closing) { /* closing.. */
 257                err = -ENOMEM;
 258                goto __error;
 259        }
 260
 261        cell = pool->free;
 262        if (cell) {
 263                int used;
 264                pool->free = cell->next;
 265                atomic_inc(&pool->counter);
 266                used = atomic_read(&pool->counter);
 267                if (pool->max_used < used)
 268                        pool->max_used = used;
 269                pool->event_alloc_success++;
 270                /* clear cell pointers */
 271                cell->next = NULL;
 272                err = 0;
 273        } else
 274                pool->event_alloc_failures++;
 275        *cellp = cell;
 276
 277__error:
 278        spin_unlock_irqrestore(&pool->lock, flags);
 279        return err;
 280}
 281
 282
 283/*
 284 * duplicate the event to a cell.
 285 * if the event has external data, the data is decomposed to additional
 286 * cells.
 287 */
 288int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event,
 289                      struct snd_seq_event_cell **cellp, int nonblock,
 290                      struct file *file)
 291{
 292        int ncells, err;
 293        unsigned int extlen;
 294        struct snd_seq_event_cell *cell;
 295
 296        *cellp = NULL;
 297
 298        ncells = 0;
 299        extlen = 0;
 300        if (snd_seq_ev_is_variable(event)) {
 301                extlen = event->data.ext.len & ~SNDRV_SEQ_EXT_MASK;
 302                ncells = (extlen + sizeof(struct snd_seq_event) - 1) / sizeof(struct snd_seq_event);
 303        }
 304        if (ncells >= pool->total_elements)
 305                return -ENOMEM;
 306
 307        err = snd_seq_cell_alloc(pool, &cell, nonblock, file);
 308        if (err < 0)
 309                return err;
 310
 311        /* copy the event */
 312        cell->event = *event;
 313
 314        /* decompose */
 315        if (snd_seq_ev_is_variable(event)) {
 316                int len = extlen;
 317                int is_chained = event->data.ext.len & SNDRV_SEQ_EXT_CHAINED;
 318                int is_usrptr = event->data.ext.len & SNDRV_SEQ_EXT_USRPTR;
 319                struct snd_seq_event_cell *src, *tmp, *tail;
 320                char *buf;
 321
 322                cell->event.data.ext.len = extlen | SNDRV_SEQ_EXT_CHAINED;
 323                cell->event.data.ext.ptr = NULL;
 324
 325                src = (struct snd_seq_event_cell *)event->data.ext.ptr;
 326                buf = (char *)event->data.ext.ptr;
 327                tail = NULL;
 328
 329                while (ncells-- > 0) {
 330                        int size = sizeof(struct snd_seq_event);
 331                        if (len < size)
 332                                size = len;
 333                        err = snd_seq_cell_alloc(pool, &tmp, nonblock, file);
 334                        if (err < 0)
 335                                goto __error;
 336                        if (cell->event.data.ext.ptr == NULL)
 337                                cell->event.data.ext.ptr = tmp;
 338                        if (tail)
 339                                tail->next = tmp;
 340                        tail = tmp;
 341                        /* copy chunk */
 342                        if (is_chained && src) {
 343                                tmp->event = src->event;
 344                                src = src->next;
 345                        } else if (is_usrptr) {
 346                                if (copy_from_user(&tmp->event, (char __user *)buf, size)) {
 347                                        err = -EFAULT;
 348                                        goto __error;
 349                                }
 350                        } else {
 351                                memcpy(&tmp->event, buf, size);
 352                        }
 353                        buf += size;
 354                        len -= size;
 355                }
 356        }
 357
 358        *cellp = cell;
 359        return 0;
 360
 361__error:
 362        snd_seq_cell_free(cell);
 363        return err;
 364}
 365  
 366
 367/* poll wait */
 368int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file,
 369                           poll_table *wait)
 370{
 371        poll_wait(file, &pool->output_sleep, wait);
 372        return snd_seq_output_ok(pool);
 373}
 374
 375
 376/* allocate room specified number of events */
 377int snd_seq_pool_init(struct snd_seq_pool *pool)
 378{
 379        int cell;
 380        struct snd_seq_event_cell *cellptr;
 381        unsigned long flags;
 382
 383        if (snd_BUG_ON(!pool))
 384                return -EINVAL;
 385        if (pool->ptr)                  /* should be atomic? */
 386                return 0;
 387
 388        pool->ptr = vmalloc(sizeof(struct snd_seq_event_cell) * pool->size);
 389        if (pool->ptr == NULL) {
 390                snd_printd("seq: malloc for sequencer events failed\n");
 391                return -ENOMEM;
 392        }
 393
 394        /* add new cells to the free cell list */
 395        spin_lock_irqsave(&pool->lock, flags);
 396        pool->free = NULL;
 397
 398        for (cell = 0; cell < pool->size; cell++) {
 399                cellptr = pool->ptr + cell;
 400                cellptr->pool = pool;
 401                cellptr->next = pool->free;
 402                pool->free = cellptr;
 403        }
 404        pool->room = (pool->size + 1) / 2;
 405
 406        /* init statistics */
 407        pool->max_used = 0;
 408        pool->total_elements = pool->size;
 409        spin_unlock_irqrestore(&pool->lock, flags);
 410        return 0;
 411}
 412
 413/* remove events */
 414int snd_seq_pool_done(struct snd_seq_pool *pool)
 415{
 416        unsigned long flags;
 417        struct snd_seq_event_cell *ptr;
 418        int max_count = 5 * HZ;
 419
 420        if (snd_BUG_ON(!pool))
 421                return -EINVAL;
 422
 423        /* wait for closing all threads */
 424        spin_lock_irqsave(&pool->lock, flags);
 425        pool->closing = 1;
 426        spin_unlock_irqrestore(&pool->lock, flags);
 427
 428        if (waitqueue_active(&pool->output_sleep))
 429                wake_up(&pool->output_sleep);
 430
 431        while (atomic_read(&pool->counter) > 0) {
 432                if (max_count == 0) {
 433                        snd_printk(KERN_WARNING "snd_seq_pool_done timeout: %d cells remain\n", atomic_read(&pool->counter));
 434                        break;
 435                }
 436                schedule_timeout_uninterruptible(1);
 437                max_count--;
 438        }
 439        
 440        /* release all resources */
 441        spin_lock_irqsave(&pool->lock, flags);
 442        ptr = pool->ptr;
 443        pool->ptr = NULL;
 444        pool->free = NULL;
 445        pool->total_elements = 0;
 446        spin_unlock_irqrestore(&pool->lock, flags);
 447
 448        vfree(ptr);
 449
 450        spin_lock_irqsave(&pool->lock, flags);
 451        pool->closing = 0;
 452        spin_unlock_irqrestore(&pool->lock, flags);
 453
 454        return 0;
 455}
 456
 457
 458/* init new memory pool */
 459struct snd_seq_pool *snd_seq_pool_new(int poolsize)
 460{
 461        struct snd_seq_pool *pool;
 462
 463        /* create pool block */
 464        pool = kzalloc(sizeof(*pool), GFP_KERNEL);
 465        if (pool == NULL) {
 466                snd_printd("seq: malloc failed for pool\n");
 467                return NULL;
 468        }
 469        spin_lock_init(&pool->lock);
 470        pool->ptr = NULL;
 471        pool->free = NULL;
 472        pool->total_elements = 0;
 473        atomic_set(&pool->counter, 0);
 474        pool->closing = 0;
 475        init_waitqueue_head(&pool->output_sleep);
 476        
 477        pool->size = poolsize;
 478
 479        /* init statistics */
 480        pool->max_used = 0;
 481        return pool;
 482}
 483
 484/* remove memory pool */
 485int snd_seq_pool_delete(struct snd_seq_pool **ppool)
 486{
 487        struct snd_seq_pool *pool = *ppool;
 488
 489        *ppool = NULL;
 490        if (pool == NULL)
 491                return 0;
 492        snd_seq_pool_done(pool);
 493        kfree(pool);
 494        return 0;
 495}
 496
 497/* initialize sequencer memory */
 498int __init snd_sequencer_memory_init(void)
 499{
 500        return 0;
 501}
 502
 503/* release sequencer memory */
 504void __exit snd_sequencer_memory_done(void)
 505{
 506}
 507
 508
 509/* exported to seq_clientmgr.c */
 510void snd_seq_info_pool(struct snd_info_buffer *buffer,
 511                       struct snd_seq_pool *pool, char *space)
 512{
 513        if (pool == NULL)
 514                return;
 515        snd_iprintf(buffer, "%sPool size          : %d\n", space, pool->total_elements);
 516        snd_iprintf(buffer, "%sCells in use       : %d\n", space, atomic_read(&pool->counter));
 517        snd_iprintf(buffer, "%sPeak cells in use  : %d\n", space, pool->max_used);
 518        snd_iprintf(buffer, "%sAlloc success      : %d\n", space, pool->event_alloc_success);
 519        snd_iprintf(buffer, "%sAlloc failures     : %d\n", space, pool->event_alloc_failures);
 520}
 521
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.