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