OSDN Git Service

perf/x86/uncore: Correct the number of CHAs on EMR
[tomoyo/tomoyo-test1.git] / sound / core / seq / seq_memory.c
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                 memset(buf + len, 0, newlen - len);
192         return newlen;
193 }
194 EXPORT_SYMBOL(snd_seq_expand_var_event);
195
196 int snd_seq_expand_var_event_at(const struct snd_seq_event *event, int count,
197                                 char *buf, int offset)
198 {
199         int len, err;
200
201         len = get_var_len(event);
202         if (len < 0)
203                 return len;
204         if (len <= offset)
205                 return 0;
206         len -= offset;
207         if (len > count)
208                 len = count;
209         err = expand_var_event(event, offset, count, buf, true);
210         if (err < 0)
211                 return err;
212         return len;
213 }
214 EXPORT_SYMBOL_GPL(snd_seq_expand_var_event_at);
215
216 /*
217  * release this cell, free extended data if available
218  */
219
220 static inline void free_cell(struct snd_seq_pool *pool,
221                              struct snd_seq_event_cell *cell)
222 {
223         cell->next = pool->free;
224         pool->free = cell;
225         atomic_dec(&pool->counter);
226 }
227
228 void snd_seq_cell_free(struct snd_seq_event_cell * cell)
229 {
230         unsigned long flags;
231         struct snd_seq_pool *pool;
232
233         if (snd_BUG_ON(!cell))
234                 return;
235         pool = cell->pool;
236         if (snd_BUG_ON(!pool))
237                 return;
238
239         spin_lock_irqsave(&pool->lock, flags);
240         free_cell(pool, cell);
241         if (snd_seq_ev_is_variable(&cell->event)) {
242                 if (cell->event.data.ext.len & SNDRV_SEQ_EXT_CHAINED) {
243                         struct snd_seq_event_cell *curp, *nextptr;
244                         curp = cell->event.data.ext.ptr;
245                         for (; curp; curp = nextptr) {
246                                 nextptr = curp->next;
247                                 curp->next = pool->free;
248                                 free_cell(pool, curp);
249                         }
250                 }
251         }
252         if (waitqueue_active(&pool->output_sleep)) {
253                 /* has enough space now? */
254                 if (snd_seq_output_ok(pool))
255                         wake_up(&pool->output_sleep);
256         }
257         spin_unlock_irqrestore(&pool->lock, flags);
258 }
259
260
261 /*
262  * allocate an event cell.
263  */
264 static int snd_seq_cell_alloc(struct snd_seq_pool *pool,
265                               struct snd_seq_event_cell **cellp,
266                               int nonblock, struct file *file,
267                               struct mutex *mutexp)
268 {
269         struct snd_seq_event_cell *cell;
270         unsigned long flags;
271         int err = -EAGAIN;
272         wait_queue_entry_t wait;
273
274         if (pool == NULL)
275                 return -EINVAL;
276
277         *cellp = NULL;
278
279         init_waitqueue_entry(&wait, current);
280         spin_lock_irqsave(&pool->lock, flags);
281         if (pool->ptr == NULL) {        /* not initialized */
282                 pr_debug("ALSA: seq: pool is not initialized\n");
283                 err = -EINVAL;
284                 goto __error;
285         }
286         while (pool->free == NULL && ! nonblock && ! pool->closing) {
287
288                 set_current_state(TASK_INTERRUPTIBLE);
289                 add_wait_queue(&pool->output_sleep, &wait);
290                 spin_unlock_irqrestore(&pool->lock, flags);
291                 if (mutexp)
292                         mutex_unlock(mutexp);
293                 schedule();
294                 if (mutexp)
295                         mutex_lock(mutexp);
296                 spin_lock_irqsave(&pool->lock, flags);
297                 remove_wait_queue(&pool->output_sleep, &wait);
298                 /* interrupted? */
299                 if (signal_pending(current)) {
300                         err = -ERESTARTSYS;
301                         goto __error;
302                 }
303         }
304         if (pool->closing) { /* closing.. */
305                 err = -ENOMEM;
306                 goto __error;
307         }
308
309         cell = pool->free;
310         if (cell) {
311                 int used;
312                 pool->free = cell->next;
313                 atomic_inc(&pool->counter);
314                 used = atomic_read(&pool->counter);
315                 if (pool->max_used < used)
316                         pool->max_used = used;
317                 pool->event_alloc_success++;
318                 /* clear cell pointers */
319                 cell->next = NULL;
320                 err = 0;
321         } else
322                 pool->event_alloc_failures++;
323         *cellp = cell;
324
325 __error:
326         spin_unlock_irqrestore(&pool->lock, flags);
327         return err;
328 }
329
330
331 /*
332  * duplicate the event to a cell.
333  * if the event has external data, the data is decomposed to additional
334  * cells.
335  */
336 int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event,
337                       struct snd_seq_event_cell **cellp, int nonblock,
338                       struct file *file, struct mutex *mutexp)
339 {
340         int ncells, err;
341         unsigned int extlen;
342         struct snd_seq_event_cell *cell;
343         int size;
344
345         *cellp = NULL;
346
347         ncells = 0;
348         extlen = 0;
349         if (snd_seq_ev_is_variable(event)) {
350                 extlen = event->data.ext.len & ~SNDRV_SEQ_EXT_MASK;
351                 ncells = DIV_ROUND_UP(extlen, sizeof(struct snd_seq_event));
352         }
353         if (ncells >= pool->total_elements)
354                 return -ENOMEM;
355
356         err = snd_seq_cell_alloc(pool, &cell, nonblock, file, mutexp);
357         if (err < 0)
358                 return err;
359
360         /* copy the event */
361         size = snd_seq_event_packet_size(event);
362         memcpy(&cell->ump, event, size);
363 #if IS_ENABLED(CONFIG_SND_SEQ_UMP)
364         if (size < sizeof(cell->event))
365                 cell->ump.raw.extra = 0;
366 #endif
367
368         /* decompose */
369         if (snd_seq_ev_is_variable(event)) {
370                 int len = extlen;
371                 int is_chained = event->data.ext.len & SNDRV_SEQ_EXT_CHAINED;
372                 int is_usrptr = event->data.ext.len & SNDRV_SEQ_EXT_USRPTR;
373                 struct snd_seq_event_cell *src, *tmp, *tail;
374                 char *buf;
375
376                 cell->event.data.ext.len = extlen | SNDRV_SEQ_EXT_CHAINED;
377                 cell->event.data.ext.ptr = NULL;
378
379                 src = (struct snd_seq_event_cell *)event->data.ext.ptr;
380                 buf = (char *)event->data.ext.ptr;
381                 tail = NULL;
382
383                 while (ncells-- > 0) {
384                         size = sizeof(struct snd_seq_event);
385                         if (len < size)
386                                 size = len;
387                         err = snd_seq_cell_alloc(pool, &tmp, nonblock, file,
388                                                  mutexp);
389                         if (err < 0)
390                                 goto __error;
391                         if (cell->event.data.ext.ptr == NULL)
392                                 cell->event.data.ext.ptr = tmp;
393                         if (tail)
394                                 tail->next = tmp;
395                         tail = tmp;
396                         /* copy chunk */
397                         if (is_chained && src) {
398                                 tmp->event = src->event;
399                                 src = src->next;
400                         } else if (is_usrptr) {
401                                 if (copy_from_user(&tmp->event, (char __force __user *)buf, size)) {
402                                         err = -EFAULT;
403                                         goto __error;
404                                 }
405                         } else {
406                                 memcpy(&tmp->event, buf, size);
407                         }
408                         buf += size;
409                         len -= size;
410                 }
411         }
412
413         *cellp = cell;
414         return 0;
415
416 __error:
417         snd_seq_cell_free(cell);
418         return err;
419 }
420   
421
422 /* poll wait */
423 int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file,
424                            poll_table *wait)
425 {
426         poll_wait(file, &pool->output_sleep, wait);
427         return snd_seq_output_ok(pool);
428 }
429
430
431 /* allocate room specified number of events */
432 int snd_seq_pool_init(struct snd_seq_pool *pool)
433 {
434         int cell;
435         struct snd_seq_event_cell *cellptr;
436
437         if (snd_BUG_ON(!pool))
438                 return -EINVAL;
439
440         cellptr = kvmalloc_array(sizeof(struct snd_seq_event_cell), pool->size,
441                                  GFP_KERNEL);
442         if (!cellptr)
443                 return -ENOMEM;
444
445         /* add new cells to the free cell list */
446         spin_lock_irq(&pool->lock);
447         if (pool->ptr) {
448                 spin_unlock_irq(&pool->lock);
449                 kvfree(cellptr);
450                 return 0;
451         }
452
453         pool->ptr = cellptr;
454         pool->free = NULL;
455
456         for (cell = 0; cell < pool->size; cell++) {
457                 cellptr = pool->ptr + cell;
458                 cellptr->pool = pool;
459                 cellptr->next = pool->free;
460                 pool->free = cellptr;
461         }
462         pool->room = (pool->size + 1) / 2;
463
464         /* init statistics */
465         pool->max_used = 0;
466         pool->total_elements = pool->size;
467         spin_unlock_irq(&pool->lock);
468         return 0;
469 }
470
471 /* refuse the further insertion to the pool */
472 void snd_seq_pool_mark_closing(struct snd_seq_pool *pool)
473 {
474         unsigned long flags;
475
476         if (snd_BUG_ON(!pool))
477                 return;
478         spin_lock_irqsave(&pool->lock, flags);
479         pool->closing = 1;
480         spin_unlock_irqrestore(&pool->lock, flags);
481 }
482
483 /* remove events */
484 int snd_seq_pool_done(struct snd_seq_pool *pool)
485 {
486         struct snd_seq_event_cell *ptr;
487
488         if (snd_BUG_ON(!pool))
489                 return -EINVAL;
490
491         /* wait for closing all threads */
492         if (waitqueue_active(&pool->output_sleep))
493                 wake_up(&pool->output_sleep);
494
495         while (atomic_read(&pool->counter) > 0)
496                 schedule_timeout_uninterruptible(1);
497         
498         /* release all resources */
499         spin_lock_irq(&pool->lock);
500         ptr = pool->ptr;
501         pool->ptr = NULL;
502         pool->free = NULL;
503         pool->total_elements = 0;
504         spin_unlock_irq(&pool->lock);
505
506         kvfree(ptr);
507
508         spin_lock_irq(&pool->lock);
509         pool->closing = 0;
510         spin_unlock_irq(&pool->lock);
511
512         return 0;
513 }
514
515
516 /* init new memory pool */
517 struct snd_seq_pool *snd_seq_pool_new(int poolsize)
518 {
519         struct snd_seq_pool *pool;
520
521         /* create pool block */
522         pool = kzalloc(sizeof(*pool), GFP_KERNEL);
523         if (!pool)
524                 return NULL;
525         spin_lock_init(&pool->lock);
526         pool->ptr = NULL;
527         pool->free = NULL;
528         pool->total_elements = 0;
529         atomic_set(&pool->counter, 0);
530         pool->closing = 0;
531         init_waitqueue_head(&pool->output_sleep);
532         
533         pool->size = poolsize;
534
535         /* init statistics */
536         pool->max_used = 0;
537         return pool;
538 }
539
540 /* remove memory pool */
541 int snd_seq_pool_delete(struct snd_seq_pool **ppool)
542 {
543         struct snd_seq_pool *pool = *ppool;
544
545         *ppool = NULL;
546         if (pool == NULL)
547                 return 0;
548         snd_seq_pool_mark_closing(pool);
549         snd_seq_pool_done(pool);
550         kfree(pool);
551         return 0;
552 }
553
554 /* exported to seq_clientmgr.c */
555 void snd_seq_info_pool(struct snd_info_buffer *buffer,
556                        struct snd_seq_pool *pool, char *space)
557 {
558         if (pool == NULL)
559                 return;
560         snd_iprintf(buffer, "%sPool size          : %d\n", space, pool->total_elements);
561         snd_iprintf(buffer, "%sCells in use       : %d\n", space, atomic_read(&pool->counter));
562         snd_iprintf(buffer, "%sPeak cells in use  : %d\n", space, pool->max_used);
563         snd_iprintf(buffer, "%sAlloc success      : %d\n", space, pool->event_alloc_success);
564         snd_iprintf(buffer, "%sAlloc failures     : %d\n", space, pool->event_alloc_failures);
565 }