Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  ALSA sequencer Client Manager
0004  *  Copyright (c) 1998-2001 by Frank van de Pol <fvdpol@coil.demon.nl>
0005  *                             Jaroslav Kysela <perex@perex.cz>
0006  *                             Takashi Iwai <tiwai@suse.de>
0007  */
0008 
0009 #include <linux/init.h>
0010 #include <linux/export.h>
0011 #include <linux/slab.h>
0012 #include <sound/core.h>
0013 #include <sound/minors.h>
0014 #include <linux/kmod.h>
0015 
0016 #include <sound/seq_kernel.h>
0017 #include "seq_clientmgr.h"
0018 #include "seq_memory.h"
0019 #include "seq_queue.h"
0020 #include "seq_timer.h"
0021 #include "seq_info.h"
0022 #include "seq_system.h"
0023 #include <sound/seq_device.h>
0024 #ifdef CONFIG_COMPAT
0025 #include <linux/compat.h>
0026 #endif
0027 
0028 /* Client Manager
0029 
0030  * this module handles the connections of userland and kernel clients
0031  * 
0032  */
0033 
0034 /*
0035  * There are four ranges of client numbers (last two shared):
0036  * 0..15: global clients
0037  * 16..127: statically allocated client numbers for cards 0..27
0038  * 128..191: dynamically allocated client numbers for cards 28..31
0039  * 128..191: dynamically allocated client numbers for applications
0040  */
0041 
0042 /* number of kernel non-card clients */
0043 #define SNDRV_SEQ_GLOBAL_CLIENTS    16
0044 /* clients per cards, for static clients */
0045 #define SNDRV_SEQ_CLIENTS_PER_CARD  4
0046 /* dynamically allocated client numbers (both kernel drivers and user space) */
0047 #define SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN 128
0048 
0049 #define SNDRV_SEQ_LFLG_INPUT    0x0001
0050 #define SNDRV_SEQ_LFLG_OUTPUT   0x0002
0051 #define SNDRV_SEQ_LFLG_OPEN (SNDRV_SEQ_LFLG_INPUT|SNDRV_SEQ_LFLG_OUTPUT)
0052 
0053 static DEFINE_SPINLOCK(clients_lock);
0054 static DEFINE_MUTEX(register_mutex);
0055 
0056 /*
0057  * client table
0058  */
0059 static char clienttablock[SNDRV_SEQ_MAX_CLIENTS];
0060 static struct snd_seq_client *clienttab[SNDRV_SEQ_MAX_CLIENTS];
0061 static struct snd_seq_usage client_usage;
0062 
0063 /*
0064  * prototypes
0065  */
0066 static int bounce_error_event(struct snd_seq_client *client,
0067                   struct snd_seq_event *event,
0068                   int err, int atomic, int hop);
0069 static int snd_seq_deliver_single_event(struct snd_seq_client *client,
0070                     struct snd_seq_event *event,
0071                     int filter, int atomic, int hop);
0072 
0073 /*
0074  */
0075 static inline unsigned short snd_seq_file_flags(struct file *file)
0076 {
0077         switch (file->f_mode & (FMODE_READ | FMODE_WRITE)) {
0078         case FMODE_WRITE:
0079                 return SNDRV_SEQ_LFLG_OUTPUT;
0080         case FMODE_READ:
0081                 return SNDRV_SEQ_LFLG_INPUT;
0082         default:
0083                 return SNDRV_SEQ_LFLG_OPEN;
0084         }
0085 }
0086 
0087 static inline int snd_seq_write_pool_allocated(struct snd_seq_client *client)
0088 {
0089     return snd_seq_total_cells(client->pool) > 0;
0090 }
0091 
0092 /* return pointer to client structure for specified id */
0093 static struct snd_seq_client *clientptr(int clientid)
0094 {
0095     if (clientid < 0 || clientid >= SNDRV_SEQ_MAX_CLIENTS) {
0096         pr_debug("ALSA: seq: oops. Trying to get pointer to client %d\n",
0097                clientid);
0098         return NULL;
0099     }
0100     return clienttab[clientid];
0101 }
0102 
0103 struct snd_seq_client *snd_seq_client_use_ptr(int clientid)
0104 {
0105     unsigned long flags;
0106     struct snd_seq_client *client;
0107 
0108     if (clientid < 0 || clientid >= SNDRV_SEQ_MAX_CLIENTS) {
0109         pr_debug("ALSA: seq: oops. Trying to get pointer to client %d\n",
0110                clientid);
0111         return NULL;
0112     }
0113     spin_lock_irqsave(&clients_lock, flags);
0114     client = clientptr(clientid);
0115     if (client)
0116         goto __lock;
0117     if (clienttablock[clientid]) {
0118         spin_unlock_irqrestore(&clients_lock, flags);
0119         return NULL;
0120     }
0121     spin_unlock_irqrestore(&clients_lock, flags);
0122 #ifdef CONFIG_MODULES
0123     if (!in_interrupt()) {
0124         static DECLARE_BITMAP(client_requested, SNDRV_SEQ_GLOBAL_CLIENTS);
0125         static DECLARE_BITMAP(card_requested, SNDRV_CARDS);
0126 
0127         if (clientid < SNDRV_SEQ_GLOBAL_CLIENTS) {
0128             int idx;
0129             
0130             if (!test_and_set_bit(clientid, client_requested)) {
0131                 for (idx = 0; idx < 15; idx++) {
0132                     if (seq_client_load[idx] < 0)
0133                         break;
0134                     if (seq_client_load[idx] == clientid) {
0135                         request_module("snd-seq-client-%i",
0136                                    clientid);
0137                         break;
0138                     }
0139                 }
0140             }
0141         } else if (clientid < SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN) {
0142             int card = (clientid - SNDRV_SEQ_GLOBAL_CLIENTS) /
0143                 SNDRV_SEQ_CLIENTS_PER_CARD;
0144             if (card < snd_ecards_limit) {
0145                 if (!test_and_set_bit(card, card_requested))
0146                     snd_request_card(card);
0147                 snd_seq_device_load_drivers();
0148             }
0149         }
0150         spin_lock_irqsave(&clients_lock, flags);
0151         client = clientptr(clientid);
0152         if (client)
0153             goto __lock;
0154         spin_unlock_irqrestore(&clients_lock, flags);
0155     }
0156 #endif
0157     return NULL;
0158 
0159       __lock:
0160     snd_use_lock_use(&client->use_lock);
0161     spin_unlock_irqrestore(&clients_lock, flags);
0162     return client;
0163 }
0164 
0165 /* Take refcount and perform ioctl_mutex lock on the given client;
0166  * used only for OSS sequencer
0167  * Unlock via snd_seq_client_ioctl_unlock() below
0168  */
0169 bool snd_seq_client_ioctl_lock(int clientid)
0170 {
0171     struct snd_seq_client *client;
0172 
0173     client = snd_seq_client_use_ptr(clientid);
0174     if (!client)
0175         return false;
0176     mutex_lock(&client->ioctl_mutex);
0177     /* The client isn't unrefed here; see snd_seq_client_ioctl_unlock() */
0178     return true;
0179 }
0180 EXPORT_SYMBOL_GPL(snd_seq_client_ioctl_lock);
0181 
0182 /* Unlock and unref the given client; for OSS sequencer use only */
0183 void snd_seq_client_ioctl_unlock(int clientid)
0184 {
0185     struct snd_seq_client *client;
0186 
0187     client = snd_seq_client_use_ptr(clientid);
0188     if (WARN_ON(!client))
0189         return;
0190     mutex_unlock(&client->ioctl_mutex);
0191     /* The doubly unrefs below are intentional; the first one releases the
0192      * leftover from snd_seq_client_ioctl_lock() above, and the second one
0193      * is for releasing snd_seq_client_use_ptr() in this function
0194      */
0195     snd_seq_client_unlock(client);
0196     snd_seq_client_unlock(client);
0197 }
0198 EXPORT_SYMBOL_GPL(snd_seq_client_ioctl_unlock);
0199 
0200 static void usage_alloc(struct snd_seq_usage *res, int num)
0201 {
0202     res->cur += num;
0203     if (res->cur > res->peak)
0204         res->peak = res->cur;
0205 }
0206 
0207 static void usage_free(struct snd_seq_usage *res, int num)
0208 {
0209     res->cur -= num;
0210 }
0211 
0212 /* initialise data structures */
0213 int __init client_init_data(void)
0214 {
0215     /* zap out the client table */
0216     memset(&clienttablock, 0, sizeof(clienttablock));
0217     memset(&clienttab, 0, sizeof(clienttab));
0218     return 0;
0219 }
0220 
0221 
0222 static struct snd_seq_client *seq_create_client1(int client_index, int poolsize)
0223 {
0224     int c;
0225     struct snd_seq_client *client;
0226 
0227     /* init client data */
0228     client = kzalloc(sizeof(*client), GFP_KERNEL);
0229     if (client == NULL)
0230         return NULL;
0231     client->pool = snd_seq_pool_new(poolsize);
0232     if (client->pool == NULL) {
0233         kfree(client);
0234         return NULL;
0235     }
0236     client->type = NO_CLIENT;
0237     snd_use_lock_init(&client->use_lock);
0238     rwlock_init(&client->ports_lock);
0239     mutex_init(&client->ports_mutex);
0240     INIT_LIST_HEAD(&client->ports_list_head);
0241     mutex_init(&client->ioctl_mutex);
0242 
0243     /* find free slot in the client table */
0244     spin_lock_irq(&clients_lock);
0245     if (client_index < 0) {
0246         for (c = SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN;
0247              c < SNDRV_SEQ_MAX_CLIENTS;
0248              c++) {
0249             if (clienttab[c] || clienttablock[c])
0250                 continue;
0251             clienttab[client->number = c] = client;
0252             spin_unlock_irq(&clients_lock);
0253             return client;
0254         }
0255     } else {
0256         if (clienttab[client_index] == NULL && !clienttablock[client_index]) {
0257             clienttab[client->number = client_index] = client;
0258             spin_unlock_irq(&clients_lock);
0259             return client;
0260         }
0261     }
0262     spin_unlock_irq(&clients_lock);
0263     snd_seq_pool_delete(&client->pool);
0264     kfree(client);
0265     return NULL;    /* no free slot found or busy, return failure code */
0266 }
0267 
0268 
0269 static int seq_free_client1(struct snd_seq_client *client)
0270 {
0271     if (!client)
0272         return 0;
0273     spin_lock_irq(&clients_lock);
0274     clienttablock[client->number] = 1;
0275     clienttab[client->number] = NULL;
0276     spin_unlock_irq(&clients_lock);
0277     snd_seq_delete_all_ports(client);
0278     snd_seq_queue_client_leave(client->number);
0279     snd_use_lock_sync(&client->use_lock);
0280     if (client->pool)
0281         snd_seq_pool_delete(&client->pool);
0282     spin_lock_irq(&clients_lock);
0283     clienttablock[client->number] = 0;
0284     spin_unlock_irq(&clients_lock);
0285     return 0;
0286 }
0287 
0288 
0289 static void seq_free_client(struct snd_seq_client * client)
0290 {
0291     mutex_lock(&register_mutex);
0292     switch (client->type) {
0293     case NO_CLIENT:
0294         pr_warn("ALSA: seq: Trying to free unused client %d\n",
0295             client->number);
0296         break;
0297     case USER_CLIENT:
0298     case KERNEL_CLIENT:
0299         seq_free_client1(client);
0300         usage_free(&client_usage, 1);
0301         break;
0302 
0303     default:
0304         pr_err("ALSA: seq: Trying to free client %d with undefined type = %d\n",
0305                client->number, client->type);
0306     }
0307     mutex_unlock(&register_mutex);
0308 
0309     snd_seq_system_client_ev_client_exit(client->number);
0310 }
0311 
0312 
0313 
0314 /* -------------------------------------------------------- */
0315 
0316 /* create a user client */
0317 static int snd_seq_open(struct inode *inode, struct file *file)
0318 {
0319     int c, mode;            /* client id */
0320     struct snd_seq_client *client;
0321     struct snd_seq_user_client *user;
0322     int err;
0323 
0324     err = stream_open(inode, file);
0325     if (err < 0)
0326         return err;
0327 
0328     mutex_lock(&register_mutex);
0329     client = seq_create_client1(-1, SNDRV_SEQ_DEFAULT_EVENTS);
0330     if (!client) {
0331         mutex_unlock(&register_mutex);
0332         return -ENOMEM; /* failure code */
0333     }
0334 
0335     mode = snd_seq_file_flags(file);
0336     if (mode & SNDRV_SEQ_LFLG_INPUT)
0337         client->accept_input = 1;
0338     if (mode & SNDRV_SEQ_LFLG_OUTPUT)
0339         client->accept_output = 1;
0340 
0341     user = &client->data.user;
0342     user->fifo = NULL;
0343     user->fifo_pool_size = 0;
0344 
0345     if (mode & SNDRV_SEQ_LFLG_INPUT) {
0346         user->fifo_pool_size = SNDRV_SEQ_DEFAULT_CLIENT_EVENTS;
0347         user->fifo = snd_seq_fifo_new(user->fifo_pool_size);
0348         if (user->fifo == NULL) {
0349             seq_free_client1(client);
0350             kfree(client);
0351             mutex_unlock(&register_mutex);
0352             return -ENOMEM;
0353         }
0354     }
0355 
0356     usage_alloc(&client_usage, 1);
0357     client->type = USER_CLIENT;
0358     mutex_unlock(&register_mutex);
0359 
0360     c = client->number;
0361     file->private_data = client;
0362 
0363     /* fill client data */
0364     user->file = file;
0365     sprintf(client->name, "Client-%d", c);
0366     client->data.user.owner = get_pid(task_pid(current));
0367 
0368     /* make others aware this new client */
0369     snd_seq_system_client_ev_client_start(c);
0370 
0371     return 0;
0372 }
0373 
0374 /* delete a user client */
0375 static int snd_seq_release(struct inode *inode, struct file *file)
0376 {
0377     struct snd_seq_client *client = file->private_data;
0378 
0379     if (client) {
0380         seq_free_client(client);
0381         if (client->data.user.fifo)
0382             snd_seq_fifo_delete(&client->data.user.fifo);
0383         put_pid(client->data.user.owner);
0384         kfree(client);
0385     }
0386 
0387     return 0;
0388 }
0389 
0390 
0391 /* handle client read() */
0392 /* possible error values:
0393  *  -ENXIO  invalid client or file open mode
0394  *  -ENOSPC FIFO overflow (the flag is cleared after this error report)
0395  *  -EINVAL no enough user-space buffer to write the whole event
0396  *  -EFAULT seg. fault during copy to user space
0397  */
0398 static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count,
0399                 loff_t *offset)
0400 {
0401     struct snd_seq_client *client = file->private_data;
0402     struct snd_seq_fifo *fifo;
0403     int err;
0404     long result = 0;
0405     struct snd_seq_event_cell *cell;
0406 
0407     if (!(snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_INPUT))
0408         return -ENXIO;
0409 
0410     if (!access_ok(buf, count))
0411         return -EFAULT;
0412 
0413     /* check client structures are in place */
0414     if (snd_BUG_ON(!client))
0415         return -ENXIO;
0416 
0417     if (!client->accept_input)
0418         return -ENXIO;
0419     fifo = client->data.user.fifo;
0420     if (!fifo)
0421         return -ENXIO;
0422 
0423     if (atomic_read(&fifo->overflow) > 0) {
0424         /* buffer overflow is detected */
0425         snd_seq_fifo_clear(fifo);
0426         /* return error code */
0427         return -ENOSPC;
0428     }
0429 
0430     cell = NULL;
0431     err = 0;
0432     snd_seq_fifo_lock(fifo);
0433 
0434     /* while data available in queue */
0435     while (count >= sizeof(struct snd_seq_event)) {
0436         int nonblock;
0437 
0438         nonblock = (file->f_flags & O_NONBLOCK) || result > 0;
0439         err = snd_seq_fifo_cell_out(fifo, &cell, nonblock);
0440         if (err < 0)
0441             break;
0442         if (snd_seq_ev_is_variable(&cell->event)) {
0443             struct snd_seq_event tmpev;
0444             tmpev = cell->event;
0445             tmpev.data.ext.len &= ~SNDRV_SEQ_EXT_MASK;
0446             if (copy_to_user(buf, &tmpev, sizeof(struct snd_seq_event))) {
0447                 err = -EFAULT;
0448                 break;
0449             }
0450             count -= sizeof(struct snd_seq_event);
0451             buf += sizeof(struct snd_seq_event);
0452             err = snd_seq_expand_var_event(&cell->event, count,
0453                                (char __force *)buf, 0,
0454                                sizeof(struct snd_seq_event));
0455             if (err < 0)
0456                 break;
0457             result += err;
0458             count -= err;
0459             buf += err;
0460         } else {
0461             if (copy_to_user(buf, &cell->event, sizeof(struct snd_seq_event))) {
0462                 err = -EFAULT;
0463                 break;
0464             }
0465             count -= sizeof(struct snd_seq_event);
0466             buf += sizeof(struct snd_seq_event);
0467         }
0468         snd_seq_cell_free(cell);
0469         cell = NULL; /* to be sure */
0470         result += sizeof(struct snd_seq_event);
0471     }
0472 
0473     if (err < 0) {
0474         if (cell)
0475             snd_seq_fifo_cell_putback(fifo, cell);
0476         if (err == -EAGAIN && result > 0)
0477             err = 0;
0478     }
0479     snd_seq_fifo_unlock(fifo);
0480 
0481     return (err < 0) ? err : result;
0482 }
0483 
0484 
0485 /*
0486  * check access permission to the port
0487  */
0488 static int check_port_perm(struct snd_seq_client_port *port, unsigned int flags)
0489 {
0490     if ((port->capability & flags) != flags)
0491         return 0;
0492     return flags;
0493 }
0494 
0495 /*
0496  * check if the destination client is available, and return the pointer
0497  * if filter is non-zero, client filter bitmap is tested.
0498  */
0499 static struct snd_seq_client *get_event_dest_client(struct snd_seq_event *event,
0500                             int filter)
0501 {
0502     struct snd_seq_client *dest;
0503 
0504     dest = snd_seq_client_use_ptr(event->dest.client);
0505     if (dest == NULL)
0506         return NULL;
0507     if (! dest->accept_input)
0508         goto __not_avail;
0509     if ((dest->filter & SNDRV_SEQ_FILTER_USE_EVENT) &&
0510         ! test_bit(event->type, dest->event_filter))
0511         goto __not_avail;
0512     if (filter && !(dest->filter & filter))
0513         goto __not_avail;
0514 
0515     return dest; /* ok - accessible */
0516 __not_avail:
0517     snd_seq_client_unlock(dest);
0518     return NULL;
0519 }
0520 
0521 
0522 /*
0523  * Return the error event.
0524  *
0525  * If the receiver client is a user client, the original event is
0526  * encapsulated in SNDRV_SEQ_EVENT_BOUNCE as variable length event.  If
0527  * the original event is also variable length, the external data is
0528  * copied after the event record. 
0529  * If the receiver client is a kernel client, the original event is
0530  * quoted in SNDRV_SEQ_EVENT_KERNEL_ERROR, since this requires no extra
0531  * kmalloc.
0532  */
0533 static int bounce_error_event(struct snd_seq_client *client,
0534                   struct snd_seq_event *event,
0535                   int err, int atomic, int hop)
0536 {
0537     struct snd_seq_event bounce_ev;
0538     int result;
0539 
0540     if (client == NULL ||
0541         ! (client->filter & SNDRV_SEQ_FILTER_BOUNCE) ||
0542         ! client->accept_input)
0543         return 0; /* ignored */
0544 
0545     /* set up quoted error */
0546     memset(&bounce_ev, 0, sizeof(bounce_ev));
0547     bounce_ev.type = SNDRV_SEQ_EVENT_KERNEL_ERROR;
0548     bounce_ev.flags = SNDRV_SEQ_EVENT_LENGTH_FIXED;
0549     bounce_ev.queue = SNDRV_SEQ_QUEUE_DIRECT;
0550     bounce_ev.source.client = SNDRV_SEQ_CLIENT_SYSTEM;
0551     bounce_ev.source.port = SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE;
0552     bounce_ev.dest.client = client->number;
0553     bounce_ev.dest.port = event->source.port;
0554     bounce_ev.data.quote.origin = event->dest;
0555     bounce_ev.data.quote.event = event;
0556     bounce_ev.data.quote.value = -err; /* use positive value */
0557     result = snd_seq_deliver_single_event(NULL, &bounce_ev, 0, atomic, hop + 1);
0558     if (result < 0) {
0559         client->event_lost++;
0560         return result;
0561     }
0562 
0563     return result;
0564 }
0565 
0566 
0567 /*
0568  * rewrite the time-stamp of the event record with the curren time
0569  * of the given queue.
0570  * return non-zero if updated.
0571  */
0572 static int update_timestamp_of_queue(struct snd_seq_event *event,
0573                      int queue, int real_time)
0574 {
0575     struct snd_seq_queue *q;
0576 
0577     q = queueptr(queue);
0578     if (! q)
0579         return 0;
0580     event->queue = queue;
0581     event->flags &= ~SNDRV_SEQ_TIME_STAMP_MASK;
0582     if (real_time) {
0583         event->time.time = snd_seq_timer_get_cur_time(q->timer, true);
0584         event->flags |= SNDRV_SEQ_TIME_STAMP_REAL;
0585     } else {
0586         event->time.tick = snd_seq_timer_get_cur_tick(q->timer);
0587         event->flags |= SNDRV_SEQ_TIME_STAMP_TICK;
0588     }
0589     queuefree(q);
0590     return 1;
0591 }
0592 
0593 
0594 /*
0595  * deliver an event to the specified destination.
0596  * if filter is non-zero, client filter bitmap is tested.
0597  *
0598  *  RETURN VALUE: 0 : if succeeded
0599  *       <0 : error
0600  */
0601 static int snd_seq_deliver_single_event(struct snd_seq_client *client,
0602                     struct snd_seq_event *event,
0603                     int filter, int atomic, int hop)
0604 {
0605     struct snd_seq_client *dest = NULL;
0606     struct snd_seq_client_port *dest_port = NULL;
0607     int result = -ENOENT;
0608     int direct;
0609 
0610     direct = snd_seq_ev_is_direct(event);
0611 
0612     dest = get_event_dest_client(event, filter);
0613     if (dest == NULL)
0614         goto __skip;
0615     dest_port = snd_seq_port_use_ptr(dest, event->dest.port);
0616     if (dest_port == NULL)
0617         goto __skip;
0618 
0619     /* check permission */
0620     if (! check_port_perm(dest_port, SNDRV_SEQ_PORT_CAP_WRITE)) {
0621         result = -EPERM;
0622         goto __skip;
0623     }
0624         
0625     if (dest_port->timestamping)
0626         update_timestamp_of_queue(event, dest_port->time_queue,
0627                       dest_port->time_real);
0628 
0629     switch (dest->type) {
0630     case USER_CLIENT:
0631         if (dest->data.user.fifo)
0632             result = snd_seq_fifo_event_in(dest->data.user.fifo, event);
0633         break;
0634 
0635     case KERNEL_CLIENT:
0636         if (dest_port->event_input == NULL)
0637             break;
0638         result = dest_port->event_input(event, direct,
0639                         dest_port->private_data,
0640                         atomic, hop);
0641         break;
0642     default:
0643         break;
0644     }
0645 
0646   __skip:
0647     if (dest_port)
0648         snd_seq_port_unlock(dest_port);
0649     if (dest)
0650         snd_seq_client_unlock(dest);
0651 
0652     if (result < 0 && !direct) {
0653         result = bounce_error_event(client, event, result, atomic, hop);
0654     }
0655     return result;
0656 }
0657 
0658 
0659 /*
0660  * send the event to all subscribers:
0661  */
0662 static int deliver_to_subscribers(struct snd_seq_client *client,
0663                   struct snd_seq_event *event,
0664                   int atomic, int hop)
0665 {
0666     struct snd_seq_subscribers *subs;
0667     int err, result = 0, num_ev = 0;
0668     struct snd_seq_event event_saved;
0669     struct snd_seq_client_port *src_port;
0670     struct snd_seq_port_subs_info *grp;
0671 
0672     src_port = snd_seq_port_use_ptr(client, event->source.port);
0673     if (src_port == NULL)
0674         return -EINVAL; /* invalid source port */
0675     /* save original event record */
0676     event_saved = *event;
0677     grp = &src_port->c_src;
0678     
0679     /* lock list */
0680     if (atomic)
0681         read_lock(&grp->list_lock);
0682     else
0683         down_read_nested(&grp->list_mutex, hop);
0684     list_for_each_entry(subs, &grp->list_head, src_list) {
0685         /* both ports ready? */
0686         if (atomic_read(&subs->ref_count) != 2)
0687             continue;
0688         event->dest = subs->info.dest;
0689         if (subs->info.flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP)
0690             /* convert time according to flag with subscription */
0691             update_timestamp_of_queue(event, subs->info.queue,
0692                           subs->info.flags & SNDRV_SEQ_PORT_SUBS_TIME_REAL);
0693         err = snd_seq_deliver_single_event(client, event,
0694                            0, atomic, hop);
0695         if (err < 0) {
0696             /* save first error that occurs and continue */
0697             if (!result)
0698                 result = err;
0699             continue;
0700         }
0701         num_ev++;
0702         /* restore original event record */
0703         *event = event_saved;
0704     }
0705     if (atomic)
0706         read_unlock(&grp->list_lock);
0707     else
0708         up_read(&grp->list_mutex);
0709     *event = event_saved; /* restore */
0710     snd_seq_port_unlock(src_port);
0711     return (result < 0) ? result : num_ev;
0712 }
0713 
0714 
0715 #ifdef SUPPORT_BROADCAST 
0716 /*
0717  * broadcast to all ports:
0718  */
0719 static int port_broadcast_event(struct snd_seq_client *client,
0720                 struct snd_seq_event *event,
0721                 int atomic, int hop)
0722 {
0723     int num_ev = 0, err, result = 0;
0724     struct snd_seq_client *dest_client;
0725     struct snd_seq_client_port *port;
0726 
0727     dest_client = get_event_dest_client(event, SNDRV_SEQ_FILTER_BROADCAST);
0728     if (dest_client == NULL)
0729         return 0; /* no matching destination */
0730 
0731     read_lock(&dest_client->ports_lock);
0732     list_for_each_entry(port, &dest_client->ports_list_head, list) {
0733         event->dest.port = port->addr.port;
0734         /* pass NULL as source client to avoid error bounce */
0735         err = snd_seq_deliver_single_event(NULL, event,
0736                            SNDRV_SEQ_FILTER_BROADCAST,
0737                            atomic, hop);
0738         if (err < 0) {
0739             /* save first error that occurs and continue */
0740             if (!result)
0741                 result = err;
0742             continue;
0743         }
0744         num_ev++;
0745     }
0746     read_unlock(&dest_client->ports_lock);
0747     snd_seq_client_unlock(dest_client);
0748     event->dest.port = SNDRV_SEQ_ADDRESS_BROADCAST; /* restore */
0749     return (result < 0) ? result : num_ev;
0750 }
0751 
0752 /*
0753  * send the event to all clients:
0754  * if destination port is also ADDRESS_BROADCAST, deliver to all ports.
0755  */
0756 static int broadcast_event(struct snd_seq_client *client,
0757                struct snd_seq_event *event, int atomic, int hop)
0758 {
0759     int err, result = 0, num_ev = 0;
0760     int dest;
0761     struct snd_seq_addr addr;
0762 
0763     addr = event->dest; /* save */
0764 
0765     for (dest = 0; dest < SNDRV_SEQ_MAX_CLIENTS; dest++) {
0766         /* don't send to itself */
0767         if (dest == client->number)
0768             continue;
0769         event->dest.client = dest;
0770         event->dest.port = addr.port;
0771         if (addr.port == SNDRV_SEQ_ADDRESS_BROADCAST)
0772             err = port_broadcast_event(client, event, atomic, hop);
0773         else
0774             /* pass NULL as source client to avoid error bounce */
0775             err = snd_seq_deliver_single_event(NULL, event,
0776                                SNDRV_SEQ_FILTER_BROADCAST,
0777                                atomic, hop);
0778         if (err < 0) {
0779             /* save first error that occurs and continue */
0780             if (!result)
0781                 result = err;
0782             continue;
0783         }
0784         num_ev += err;
0785     }
0786     event->dest = addr; /* restore */
0787     return (result < 0) ? result : num_ev;
0788 }
0789 
0790 
0791 /* multicast - not supported yet */
0792 static int multicast_event(struct snd_seq_client *client, struct snd_seq_event *event,
0793                int atomic, int hop)
0794 {
0795     pr_debug("ALSA: seq: multicast not supported yet.\n");
0796     return 0; /* ignored */
0797 }
0798 #endif /* SUPPORT_BROADCAST */
0799 
0800 
0801 /* deliver an event to the destination port(s).
0802  * if the event is to subscribers or broadcast, the event is dispatched
0803  * to multiple targets.
0804  *
0805  * RETURN VALUE: n > 0  : the number of delivered events.
0806  *               n == 0 : the event was not passed to any client.
0807  *               n < 0  : error - event was not processed.
0808  */
0809 static int snd_seq_deliver_event(struct snd_seq_client *client, struct snd_seq_event *event,
0810                  int atomic, int hop)
0811 {
0812     int result;
0813 
0814     hop++;
0815     if (hop >= SNDRV_SEQ_MAX_HOPS) {
0816         pr_debug("ALSA: seq: too long delivery path (%d:%d->%d:%d)\n",
0817                event->source.client, event->source.port,
0818                event->dest.client, event->dest.port);
0819         return -EMLINK;
0820     }
0821 
0822     if (snd_seq_ev_is_variable(event) &&
0823         snd_BUG_ON(atomic && (event->data.ext.len & SNDRV_SEQ_EXT_USRPTR)))
0824         return -EINVAL;
0825 
0826     if (event->queue == SNDRV_SEQ_ADDRESS_SUBSCRIBERS ||
0827         event->dest.client == SNDRV_SEQ_ADDRESS_SUBSCRIBERS)
0828         result = deliver_to_subscribers(client, event, atomic, hop);
0829 #ifdef SUPPORT_BROADCAST
0830     else if (event->queue == SNDRV_SEQ_ADDRESS_BROADCAST ||
0831          event->dest.client == SNDRV_SEQ_ADDRESS_BROADCAST)
0832         result = broadcast_event(client, event, atomic, hop);
0833     else if (event->dest.client >= SNDRV_SEQ_MAX_CLIENTS)
0834         result = multicast_event(client, event, atomic, hop);
0835     else if (event->dest.port == SNDRV_SEQ_ADDRESS_BROADCAST)
0836         result = port_broadcast_event(client, event, atomic, hop);
0837 #endif
0838     else
0839         result = snd_seq_deliver_single_event(client, event, 0, atomic, hop);
0840 
0841     return result;
0842 }
0843 
0844 /*
0845  * dispatch an event cell:
0846  * This function is called only from queue check routines in timer
0847  * interrupts or after enqueued.
0848  * The event cell shall be released or re-queued in this function.
0849  *
0850  * RETURN VALUE: n > 0  : the number of delivered events.
0851  *       n == 0 : the event was not passed to any client.
0852  *       n < 0  : error - event was not processed.
0853  */
0854 int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop)
0855 {
0856     struct snd_seq_client *client;
0857     int result;
0858 
0859     if (snd_BUG_ON(!cell))
0860         return -EINVAL;
0861 
0862     client = snd_seq_client_use_ptr(cell->event.source.client);
0863     if (client == NULL) {
0864         snd_seq_cell_free(cell); /* release this cell */
0865         return -EINVAL;
0866     }
0867 
0868     if (cell->event.type == SNDRV_SEQ_EVENT_NOTE) {
0869         /* NOTE event:
0870          * the event cell is re-used as a NOTE-OFF event and
0871          * enqueued again.
0872          */
0873         struct snd_seq_event tmpev, *ev;
0874 
0875         /* reserve this event to enqueue note-off later */
0876         tmpev = cell->event;
0877         tmpev.type = SNDRV_SEQ_EVENT_NOTEON;
0878         result = snd_seq_deliver_event(client, &tmpev, atomic, hop);
0879 
0880         /*
0881          * This was originally a note event.  We now re-use the
0882          * cell for the note-off event.
0883          */
0884 
0885         ev = &cell->event;
0886         ev->type = SNDRV_SEQ_EVENT_NOTEOFF;
0887         ev->flags |= SNDRV_SEQ_PRIORITY_HIGH;
0888 
0889         /* add the duration time */
0890         switch (ev->flags & SNDRV_SEQ_TIME_STAMP_MASK) {
0891         case SNDRV_SEQ_TIME_STAMP_TICK:
0892             ev->time.tick += ev->data.note.duration;
0893             break;
0894         case SNDRV_SEQ_TIME_STAMP_REAL:
0895             /* unit for duration is ms */
0896             ev->time.time.tv_nsec += 1000000 * (ev->data.note.duration % 1000);
0897             ev->time.time.tv_sec += ev->data.note.duration / 1000 +
0898                         ev->time.time.tv_nsec / 1000000000;
0899             ev->time.time.tv_nsec %= 1000000000;
0900             break;
0901         }
0902         ev->data.note.velocity = ev->data.note.off_velocity;
0903 
0904         /* Now queue this cell as the note off event */
0905         if (snd_seq_enqueue_event(cell, atomic, hop) < 0)
0906             snd_seq_cell_free(cell); /* release this cell */
0907 
0908     } else {
0909         /* Normal events:
0910          * event cell is freed after processing the event
0911          */
0912 
0913         result = snd_seq_deliver_event(client, &cell->event, atomic, hop);
0914         snd_seq_cell_free(cell);
0915     }
0916 
0917     snd_seq_client_unlock(client);
0918     return result;
0919 }
0920 
0921 
0922 /* Allocate a cell from client pool and enqueue it to queue:
0923  * if pool is empty and blocking is TRUE, sleep until a new cell is
0924  * available.
0925  */
0926 static int snd_seq_client_enqueue_event(struct snd_seq_client *client,
0927                     struct snd_seq_event *event,
0928                     struct file *file, int blocking,
0929                     int atomic, int hop,
0930                     struct mutex *mutexp)
0931 {
0932     struct snd_seq_event_cell *cell;
0933     int err;
0934 
0935     /* special queue values - force direct passing */
0936     if (event->queue == SNDRV_SEQ_ADDRESS_SUBSCRIBERS) {
0937         event->dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
0938         event->queue = SNDRV_SEQ_QUEUE_DIRECT;
0939     } else
0940 #ifdef SUPPORT_BROADCAST
0941         if (event->queue == SNDRV_SEQ_ADDRESS_BROADCAST) {
0942             event->dest.client = SNDRV_SEQ_ADDRESS_BROADCAST;
0943             event->queue = SNDRV_SEQ_QUEUE_DIRECT;
0944         }
0945 #endif
0946     if (event->dest.client == SNDRV_SEQ_ADDRESS_SUBSCRIBERS) {
0947         /* check presence of source port */
0948         struct snd_seq_client_port *src_port = snd_seq_port_use_ptr(client, event->source.port);
0949         if (src_port == NULL)
0950             return -EINVAL;
0951         snd_seq_port_unlock(src_port);
0952     }
0953 
0954     /* direct event processing without enqueued */
0955     if (snd_seq_ev_is_direct(event)) {
0956         if (event->type == SNDRV_SEQ_EVENT_NOTE)
0957             return -EINVAL; /* this event must be enqueued! */
0958         return snd_seq_deliver_event(client, event, atomic, hop);
0959     }
0960 
0961     /* Not direct, normal queuing */
0962     if (snd_seq_queue_is_used(event->queue, client->number) <= 0)
0963         return -EINVAL;  /* invalid queue */
0964     if (! snd_seq_write_pool_allocated(client))
0965         return -ENXIO; /* queue is not allocated */
0966 
0967     /* allocate an event cell */
0968     err = snd_seq_event_dup(client->pool, event, &cell, !blocking || atomic,
0969                 file, mutexp);
0970     if (err < 0)
0971         return err;
0972 
0973     /* we got a cell. enqueue it. */
0974     err = snd_seq_enqueue_event(cell, atomic, hop);
0975     if (err < 0) {
0976         snd_seq_cell_free(cell);
0977         return err;
0978     }
0979 
0980     return 0;
0981 }
0982 
0983 
0984 /*
0985  * check validity of event type and data length.
0986  * return non-zero if invalid.
0987  */
0988 static int check_event_type_and_length(struct snd_seq_event *ev)
0989 {
0990     switch (snd_seq_ev_length_type(ev)) {
0991     case SNDRV_SEQ_EVENT_LENGTH_FIXED:
0992         if (snd_seq_ev_is_variable_type(ev))
0993             return -EINVAL;
0994         break;
0995     case SNDRV_SEQ_EVENT_LENGTH_VARIABLE:
0996         if (! snd_seq_ev_is_variable_type(ev) ||
0997             (ev->data.ext.len & ~SNDRV_SEQ_EXT_MASK) >= SNDRV_SEQ_MAX_EVENT_LEN)
0998             return -EINVAL;
0999         break;
1000     case SNDRV_SEQ_EVENT_LENGTH_VARUSR:
1001         if (! snd_seq_ev_is_direct(ev))
1002             return -EINVAL;
1003         break;
1004     }
1005     return 0;
1006 }
1007 
1008 
1009 /* handle write() */
1010 /* possible error values:
1011  *  -ENXIO  invalid client or file open mode
1012  *  -ENOMEM malloc failed
1013  *  -EFAULT seg. fault during copy from user space
1014  *  -EINVAL invalid event
1015  *  -EAGAIN no space in output pool
1016  *  -EINTR  interrupts while sleep
1017  *  -EMLINK too many hops
1018  *  others  depends on return value from driver callback
1019  */
1020 static ssize_t snd_seq_write(struct file *file, const char __user *buf,
1021                  size_t count, loff_t *offset)
1022 {
1023     struct snd_seq_client *client = file->private_data;
1024     int written = 0, len;
1025     int err, handled;
1026     struct snd_seq_event event;
1027 
1028     if (!(snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_OUTPUT))
1029         return -ENXIO;
1030 
1031     /* check client structures are in place */
1032     if (snd_BUG_ON(!client))
1033         return -ENXIO;
1034         
1035     if (!client->accept_output || client->pool == NULL)
1036         return -ENXIO;
1037 
1038  repeat:
1039     handled = 0;
1040     /* allocate the pool now if the pool is not allocated yet */ 
1041     mutex_lock(&client->ioctl_mutex);
1042     if (client->pool->size > 0 && !snd_seq_write_pool_allocated(client)) {
1043         err = snd_seq_pool_init(client->pool);
1044         if (err < 0)
1045             goto out;
1046     }
1047 
1048     /* only process whole events */
1049     err = -EINVAL;
1050     while (count >= sizeof(struct snd_seq_event)) {
1051         /* Read in the event header from the user */
1052         len = sizeof(event);
1053         if (copy_from_user(&event, buf, len)) {
1054             err = -EFAULT;
1055             break;
1056         }
1057         event.source.client = client->number;   /* fill in client number */
1058         /* Check for extension data length */
1059         if (check_event_type_and_length(&event)) {
1060             err = -EINVAL;
1061             break;
1062         }
1063 
1064         /* check for special events */
1065         if (event.type == SNDRV_SEQ_EVENT_NONE)
1066             goto __skip_event;
1067         else if (snd_seq_ev_is_reserved(&event)) {
1068             err = -EINVAL;
1069             break;
1070         }
1071 
1072         if (snd_seq_ev_is_variable(&event)) {
1073             int extlen = event.data.ext.len & ~SNDRV_SEQ_EXT_MASK;
1074             if ((size_t)(extlen + len) > count) {
1075                 /* back out, will get an error this time or next */
1076                 err = -EINVAL;
1077                 break;
1078             }
1079             /* set user space pointer */
1080             event.data.ext.len = extlen | SNDRV_SEQ_EXT_USRPTR;
1081             event.data.ext.ptr = (char __force *)buf
1082                         + sizeof(struct snd_seq_event);
1083             len += extlen; /* increment data length */
1084         } else {
1085 #ifdef CONFIG_COMPAT
1086             if (client->convert32 && snd_seq_ev_is_varusr(&event)) {
1087                 void *ptr = (void __force *)compat_ptr(event.data.raw32.d[1]);
1088                 event.data.ext.ptr = ptr;
1089             }
1090 #endif
1091         }
1092 
1093         /* ok, enqueue it */
1094         err = snd_seq_client_enqueue_event(client, &event, file,
1095                            !(file->f_flags & O_NONBLOCK),
1096                            0, 0, &client->ioctl_mutex);
1097         if (err < 0)
1098             break;
1099         handled++;
1100 
1101     __skip_event:
1102         /* Update pointers and counts */
1103         count -= len;
1104         buf += len;
1105         written += len;
1106 
1107         /* let's have a coffee break if too many events are queued */
1108         if (++handled >= 200) {
1109             mutex_unlock(&client->ioctl_mutex);
1110             goto repeat;
1111         }
1112     }
1113 
1114  out:
1115     mutex_unlock(&client->ioctl_mutex);
1116     return written ? written : err;
1117 }
1118 
1119 
1120 /*
1121  * handle polling
1122  */
1123 static __poll_t snd_seq_poll(struct file *file, poll_table * wait)
1124 {
1125     struct snd_seq_client *client = file->private_data;
1126     __poll_t mask = 0;
1127 
1128     /* check client structures are in place */
1129     if (snd_BUG_ON(!client))
1130         return EPOLLERR;
1131 
1132     if ((snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_INPUT) &&
1133         client->data.user.fifo) {
1134 
1135         /* check if data is available in the outqueue */
1136         if (snd_seq_fifo_poll_wait(client->data.user.fifo, file, wait))
1137             mask |= EPOLLIN | EPOLLRDNORM;
1138     }
1139 
1140     if (snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_OUTPUT) {
1141 
1142         /* check if data is available in the pool */
1143         if (!snd_seq_write_pool_allocated(client) ||
1144             snd_seq_pool_poll_wait(client->pool, file, wait))
1145             mask |= EPOLLOUT | EPOLLWRNORM;
1146     }
1147 
1148     return mask;
1149 }
1150 
1151 
1152 /*-----------------------------------------------------*/
1153 
1154 static int snd_seq_ioctl_pversion(struct snd_seq_client *client, void *arg)
1155 {
1156     int *pversion = arg;
1157 
1158     *pversion = SNDRV_SEQ_VERSION;
1159     return 0;
1160 }
1161 
1162 static int snd_seq_ioctl_client_id(struct snd_seq_client *client, void *arg)
1163 {
1164     int *client_id = arg;
1165 
1166     *client_id = client->number;
1167     return 0;
1168 }
1169 
1170 /* SYSTEM_INFO ioctl() */
1171 static int snd_seq_ioctl_system_info(struct snd_seq_client *client, void *arg)
1172 {
1173     struct snd_seq_system_info *info = arg;
1174 
1175     memset(info, 0, sizeof(*info));
1176     /* fill the info fields */
1177     info->queues = SNDRV_SEQ_MAX_QUEUES;
1178     info->clients = SNDRV_SEQ_MAX_CLIENTS;
1179     info->ports = SNDRV_SEQ_MAX_PORTS;
1180     info->channels = 256;   /* fixed limit */
1181     info->cur_clients = client_usage.cur;
1182     info->cur_queues = snd_seq_queue_get_cur_queues();
1183 
1184     return 0;
1185 }
1186 
1187 
1188 /* RUNNING_MODE ioctl() */
1189 static int snd_seq_ioctl_running_mode(struct snd_seq_client *client, void  *arg)
1190 {
1191     struct snd_seq_running_info *info = arg;
1192     struct snd_seq_client *cptr;
1193     int err = 0;
1194 
1195     /* requested client number */
1196     cptr = snd_seq_client_use_ptr(info->client);
1197     if (cptr == NULL)
1198         return -ENOENT;     /* don't change !!! */
1199 
1200 #ifdef SNDRV_BIG_ENDIAN
1201     if (!info->big_endian) {
1202         err = -EINVAL;
1203         goto __err;
1204     }
1205 #else
1206     if (info->big_endian) {
1207         err = -EINVAL;
1208         goto __err;
1209     }
1210 
1211 #endif
1212     if (info->cpu_mode > sizeof(long)) {
1213         err = -EINVAL;
1214         goto __err;
1215     }
1216     cptr->convert32 = (info->cpu_mode < sizeof(long));
1217  __err:
1218     snd_seq_client_unlock(cptr);
1219     return err;
1220 }
1221 
1222 /* CLIENT_INFO ioctl() */
1223 static void get_client_info(struct snd_seq_client *cptr,
1224                 struct snd_seq_client_info *info)
1225 {
1226     info->client = cptr->number;
1227 
1228     /* fill the info fields */
1229     info->type = cptr->type;
1230     strcpy(info->name, cptr->name);
1231     info->filter = cptr->filter;
1232     info->event_lost = cptr->event_lost;
1233     memcpy(info->event_filter, cptr->event_filter, 32);
1234     info->num_ports = cptr->num_ports;
1235 
1236     if (cptr->type == USER_CLIENT)
1237         info->pid = pid_vnr(cptr->data.user.owner);
1238     else
1239         info->pid = -1;
1240 
1241     if (cptr->type == KERNEL_CLIENT)
1242         info->card = cptr->data.kernel.card ? cptr->data.kernel.card->number : -1;
1243     else
1244         info->card = -1;
1245 
1246     memset(info->reserved, 0, sizeof(info->reserved));
1247 }
1248 
1249 static int snd_seq_ioctl_get_client_info(struct snd_seq_client *client,
1250                      void *arg)
1251 {
1252     struct snd_seq_client_info *client_info = arg;
1253     struct snd_seq_client *cptr;
1254 
1255     /* requested client number */
1256     cptr = snd_seq_client_use_ptr(client_info->client);
1257     if (cptr == NULL)
1258         return -ENOENT;     /* don't change !!! */
1259 
1260     get_client_info(cptr, client_info);
1261     snd_seq_client_unlock(cptr);
1262 
1263     return 0;
1264 }
1265 
1266 
1267 /* CLIENT_INFO ioctl() */
1268 static int snd_seq_ioctl_set_client_info(struct snd_seq_client *client,
1269                      void *arg)
1270 {
1271     struct snd_seq_client_info *client_info = arg;
1272 
1273     /* it is not allowed to set the info fields for an another client */
1274     if (client->number != client_info->client)
1275         return -EPERM;
1276     /* also client type must be set now */
1277     if (client->type != client_info->type)
1278         return -EINVAL;
1279 
1280     /* fill the info fields */
1281     if (client_info->name[0])
1282         strscpy(client->name, client_info->name, sizeof(client->name));
1283 
1284     client->filter = client_info->filter;
1285     client->event_lost = client_info->event_lost;
1286     memcpy(client->event_filter, client_info->event_filter, 32);
1287 
1288     return 0;
1289 }
1290 
1291 
1292 /* 
1293  * CREATE PORT ioctl() 
1294  */
1295 static int snd_seq_ioctl_create_port(struct snd_seq_client *client, void *arg)
1296 {
1297     struct snd_seq_port_info *info = arg;
1298     struct snd_seq_client_port *port;
1299     struct snd_seq_port_callback *callback;
1300     int port_idx;
1301 
1302     /* it is not allowed to create the port for an another client */
1303     if (info->addr.client != client->number)
1304         return -EPERM;
1305 
1306     port = snd_seq_create_port(client, (info->flags & SNDRV_SEQ_PORT_FLG_GIVEN_PORT) ? info->addr.port : -1);
1307     if (port == NULL)
1308         return -ENOMEM;
1309 
1310     if (client->type == USER_CLIENT && info->kernel) {
1311         port_idx = port->addr.port;
1312         snd_seq_port_unlock(port);
1313         snd_seq_delete_port(client, port_idx);
1314         return -EINVAL;
1315     }
1316     if (client->type == KERNEL_CLIENT) {
1317         callback = info->kernel;
1318         if (callback) {
1319             if (callback->owner)
1320                 port->owner = callback->owner;
1321             port->private_data = callback->private_data;
1322             port->private_free = callback->private_free;
1323             port->event_input = callback->event_input;
1324             port->c_src.open = callback->subscribe;
1325             port->c_src.close = callback->unsubscribe;
1326             port->c_dest.open = callback->use;
1327             port->c_dest.close = callback->unuse;
1328         }
1329     }
1330 
1331     info->addr = port->addr;
1332 
1333     snd_seq_set_port_info(port, info);
1334     snd_seq_system_client_ev_port_start(port->addr.client, port->addr.port);
1335     snd_seq_port_unlock(port);
1336 
1337     return 0;
1338 }
1339 
1340 /* 
1341  * DELETE PORT ioctl() 
1342  */
1343 static int snd_seq_ioctl_delete_port(struct snd_seq_client *client, void *arg)
1344 {
1345     struct snd_seq_port_info *info = arg;
1346     int err;
1347 
1348     /* it is not allowed to remove the port for an another client */
1349     if (info->addr.client != client->number)
1350         return -EPERM;
1351 
1352     err = snd_seq_delete_port(client, info->addr.port);
1353     if (err >= 0)
1354         snd_seq_system_client_ev_port_exit(client->number, info->addr.port);
1355     return err;
1356 }
1357 
1358 
1359 /* 
1360  * GET_PORT_INFO ioctl() (on any client) 
1361  */
1362 static int snd_seq_ioctl_get_port_info(struct snd_seq_client *client, void *arg)
1363 {
1364     struct snd_seq_port_info *info = arg;
1365     struct snd_seq_client *cptr;
1366     struct snd_seq_client_port *port;
1367 
1368     cptr = snd_seq_client_use_ptr(info->addr.client);
1369     if (cptr == NULL)
1370         return -ENXIO;
1371 
1372     port = snd_seq_port_use_ptr(cptr, info->addr.port);
1373     if (port == NULL) {
1374         snd_seq_client_unlock(cptr);
1375         return -ENOENT;         /* don't change */
1376     }
1377 
1378     /* get port info */
1379     snd_seq_get_port_info(port, info);
1380     snd_seq_port_unlock(port);
1381     snd_seq_client_unlock(cptr);
1382 
1383     return 0;
1384 }
1385 
1386 
1387 /* 
1388  * SET_PORT_INFO ioctl() (only ports on this/own client) 
1389  */
1390 static int snd_seq_ioctl_set_port_info(struct snd_seq_client *client, void *arg)
1391 {
1392     struct snd_seq_port_info *info = arg;
1393     struct snd_seq_client_port *port;
1394 
1395     if (info->addr.client != client->number) /* only set our own ports ! */
1396         return -EPERM;
1397     port = snd_seq_port_use_ptr(client, info->addr.port);
1398     if (port) {
1399         snd_seq_set_port_info(port, info);
1400         snd_seq_port_unlock(port);
1401     }
1402     return 0;
1403 }
1404 
1405 
1406 /*
1407  * port subscription (connection)
1408  */
1409 #define PERM_RD     (SNDRV_SEQ_PORT_CAP_READ|SNDRV_SEQ_PORT_CAP_SUBS_READ)
1410 #define PERM_WR     (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_SUBS_WRITE)
1411 
1412 static int check_subscription_permission(struct snd_seq_client *client,
1413                      struct snd_seq_client_port *sport,
1414                      struct snd_seq_client_port *dport,
1415                      struct snd_seq_port_subscribe *subs)
1416 {
1417     if (client->number != subs->sender.client &&
1418         client->number != subs->dest.client) {
1419         /* connection by third client - check export permission */
1420         if (check_port_perm(sport, SNDRV_SEQ_PORT_CAP_NO_EXPORT))
1421             return -EPERM;
1422         if (check_port_perm(dport, SNDRV_SEQ_PORT_CAP_NO_EXPORT))
1423             return -EPERM;
1424     }
1425 
1426     /* check read permission */
1427     /* if sender or receiver is the subscribing client itself,
1428      * no permission check is necessary
1429      */
1430     if (client->number != subs->sender.client) {
1431         if (! check_port_perm(sport, PERM_RD))
1432             return -EPERM;
1433     }
1434     /* check write permission */
1435     if (client->number != subs->dest.client) {
1436         if (! check_port_perm(dport, PERM_WR))
1437             return -EPERM;
1438     }
1439     return 0;
1440 }
1441 
1442 /*
1443  * send an subscription notify event to user client:
1444  * client must be user client.
1445  */
1446 int snd_seq_client_notify_subscription(int client, int port,
1447                        struct snd_seq_port_subscribe *info,
1448                        int evtype)
1449 {
1450     struct snd_seq_event event;
1451 
1452     memset(&event, 0, sizeof(event));
1453     event.type = evtype;
1454     event.data.connect.dest = info->dest;
1455     event.data.connect.sender = info->sender;
1456 
1457     return snd_seq_system_notify(client, port, &event);  /* non-atomic */
1458 }
1459 
1460 
1461 /* 
1462  * add to port's subscription list IOCTL interface 
1463  */
1464 static int snd_seq_ioctl_subscribe_port(struct snd_seq_client *client,
1465                     void *arg)
1466 {
1467     struct snd_seq_port_subscribe *subs = arg;
1468     int result = -EINVAL;
1469     struct snd_seq_client *receiver = NULL, *sender = NULL;
1470     struct snd_seq_client_port *sport = NULL, *dport = NULL;
1471 
1472     receiver = snd_seq_client_use_ptr(subs->dest.client);
1473     if (!receiver)
1474         goto __end;
1475     sender = snd_seq_client_use_ptr(subs->sender.client);
1476     if (!sender)
1477         goto __end;
1478     sport = snd_seq_port_use_ptr(sender, subs->sender.port);
1479     if (!sport)
1480         goto __end;
1481     dport = snd_seq_port_use_ptr(receiver, subs->dest.port);
1482     if (!dport)
1483         goto __end;
1484 
1485     result = check_subscription_permission(client, sport, dport, subs);
1486     if (result < 0)
1487         goto __end;
1488 
1489     /* connect them */
1490     result = snd_seq_port_connect(client, sender, sport, receiver, dport, subs);
1491     if (! result) /* broadcast announce */
1492         snd_seq_client_notify_subscription(SNDRV_SEQ_ADDRESS_SUBSCRIBERS, 0,
1493                            subs, SNDRV_SEQ_EVENT_PORT_SUBSCRIBED);
1494       __end:
1495         if (sport)
1496         snd_seq_port_unlock(sport);
1497     if (dport)
1498         snd_seq_port_unlock(dport);
1499     if (sender)
1500         snd_seq_client_unlock(sender);
1501     if (receiver)
1502         snd_seq_client_unlock(receiver);
1503     return result;
1504 }
1505 
1506 
1507 /* 
1508  * remove from port's subscription list 
1509  */
1510 static int snd_seq_ioctl_unsubscribe_port(struct snd_seq_client *client,
1511                       void *arg)
1512 {
1513     struct snd_seq_port_subscribe *subs = arg;
1514     int result = -ENXIO;
1515     struct snd_seq_client *receiver = NULL, *sender = NULL;
1516     struct snd_seq_client_port *sport = NULL, *dport = NULL;
1517 
1518     receiver = snd_seq_client_use_ptr(subs->dest.client);
1519     if (!receiver)
1520         goto __end;
1521     sender = snd_seq_client_use_ptr(subs->sender.client);
1522     if (!sender)
1523         goto __end;
1524     sport = snd_seq_port_use_ptr(sender, subs->sender.port);
1525     if (!sport)
1526         goto __end;
1527     dport = snd_seq_port_use_ptr(receiver, subs->dest.port);
1528     if (!dport)
1529         goto __end;
1530 
1531     result = check_subscription_permission(client, sport, dport, subs);
1532     if (result < 0)
1533         goto __end;
1534 
1535     result = snd_seq_port_disconnect(client, sender, sport, receiver, dport, subs);
1536     if (! result) /* broadcast announce */
1537         snd_seq_client_notify_subscription(SNDRV_SEQ_ADDRESS_SUBSCRIBERS, 0,
1538                            subs, SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED);
1539       __end:
1540         if (sport)
1541         snd_seq_port_unlock(sport);
1542     if (dport)
1543         snd_seq_port_unlock(dport);
1544     if (sender)
1545         snd_seq_client_unlock(sender);
1546     if (receiver)
1547         snd_seq_client_unlock(receiver);
1548     return result;
1549 }
1550 
1551 
1552 /* CREATE_QUEUE ioctl() */
1553 static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, void *arg)
1554 {
1555     struct snd_seq_queue_info *info = arg;
1556     struct snd_seq_queue *q;
1557 
1558     q = snd_seq_queue_alloc(client->number, info->locked, info->flags);
1559     if (IS_ERR(q))
1560         return PTR_ERR(q);
1561 
1562     info->queue = q->queue;
1563     info->locked = q->locked;
1564     info->owner = q->owner;
1565 
1566     /* set queue name */
1567     if (!info->name[0])
1568         snprintf(info->name, sizeof(info->name), "Queue-%d", q->queue);
1569     strscpy(q->name, info->name, sizeof(q->name));
1570     snd_use_lock_free(&q->use_lock);
1571 
1572     return 0;
1573 }
1574 
1575 /* DELETE_QUEUE ioctl() */
1576 static int snd_seq_ioctl_delete_queue(struct snd_seq_client *client, void *arg)
1577 {
1578     struct snd_seq_queue_info *info = arg;
1579 
1580     return snd_seq_queue_delete(client->number, info->queue);
1581 }
1582 
1583 /* GET_QUEUE_INFO ioctl() */
1584 static int snd_seq_ioctl_get_queue_info(struct snd_seq_client *client,
1585                     void *arg)
1586 {
1587     struct snd_seq_queue_info *info = arg;
1588     struct snd_seq_queue *q;
1589 
1590     q = queueptr(info->queue);
1591     if (q == NULL)
1592         return -EINVAL;
1593 
1594     memset(info, 0, sizeof(*info));
1595     info->queue = q->queue;
1596     info->owner = q->owner;
1597     info->locked = q->locked;
1598     strscpy(info->name, q->name, sizeof(info->name));
1599     queuefree(q);
1600 
1601     return 0;
1602 }
1603 
1604 /* SET_QUEUE_INFO ioctl() */
1605 static int snd_seq_ioctl_set_queue_info(struct snd_seq_client *client,
1606                     void *arg)
1607 {
1608     struct snd_seq_queue_info *info = arg;
1609     struct snd_seq_queue *q;
1610 
1611     if (info->owner != client->number)
1612         return -EINVAL;
1613 
1614     /* change owner/locked permission */
1615     if (snd_seq_queue_check_access(info->queue, client->number)) {
1616         if (snd_seq_queue_set_owner(info->queue, client->number, info->locked) < 0)
1617             return -EPERM;
1618         if (info->locked)
1619             snd_seq_queue_use(info->queue, client->number, 1);
1620     } else {
1621         return -EPERM;
1622     }   
1623 
1624     q = queueptr(info->queue);
1625     if (! q)
1626         return -EINVAL;
1627     if (q->owner != client->number) {
1628         queuefree(q);
1629         return -EPERM;
1630     }
1631     strscpy(q->name, info->name, sizeof(q->name));
1632     queuefree(q);
1633 
1634     return 0;
1635 }
1636 
1637 /* GET_NAMED_QUEUE ioctl() */
1638 static int snd_seq_ioctl_get_named_queue(struct snd_seq_client *client,
1639                      void *arg)
1640 {
1641     struct snd_seq_queue_info *info = arg;
1642     struct snd_seq_queue *q;
1643 
1644     q = snd_seq_queue_find_name(info->name);
1645     if (q == NULL)
1646         return -EINVAL;
1647     info->queue = q->queue;
1648     info->owner = q->owner;
1649     info->locked = q->locked;
1650     queuefree(q);
1651 
1652     return 0;
1653 }
1654 
1655 /* GET_QUEUE_STATUS ioctl() */
1656 static int snd_seq_ioctl_get_queue_status(struct snd_seq_client *client,
1657                       void *arg)
1658 {
1659     struct snd_seq_queue_status *status = arg;
1660     struct snd_seq_queue *queue;
1661     struct snd_seq_timer *tmr;
1662 
1663     queue = queueptr(status->queue);
1664     if (queue == NULL)
1665         return -EINVAL;
1666     memset(status, 0, sizeof(*status));
1667     status->queue = queue->queue;
1668     
1669     tmr = queue->timer;
1670     status->events = queue->tickq->cells + queue->timeq->cells;
1671 
1672     status->time = snd_seq_timer_get_cur_time(tmr, true);
1673     status->tick = snd_seq_timer_get_cur_tick(tmr);
1674 
1675     status->running = tmr->running;
1676 
1677     status->flags = queue->flags;
1678     queuefree(queue);
1679 
1680     return 0;
1681 }
1682 
1683 
1684 /* GET_QUEUE_TEMPO ioctl() */
1685 static int snd_seq_ioctl_get_queue_tempo(struct snd_seq_client *client,
1686                      void *arg)
1687 {
1688     struct snd_seq_queue_tempo *tempo = arg;
1689     struct snd_seq_queue *queue;
1690     struct snd_seq_timer *tmr;
1691 
1692     queue = queueptr(tempo->queue);
1693     if (queue == NULL)
1694         return -EINVAL;
1695     memset(tempo, 0, sizeof(*tempo));
1696     tempo->queue = queue->queue;
1697     
1698     tmr = queue->timer;
1699 
1700     tempo->tempo = tmr->tempo;
1701     tempo->ppq = tmr->ppq;
1702     tempo->skew_value = tmr->skew;
1703     tempo->skew_base = tmr->skew_base;
1704     queuefree(queue);
1705 
1706     return 0;
1707 }
1708 
1709 
1710 /* SET_QUEUE_TEMPO ioctl() */
1711 int snd_seq_set_queue_tempo(int client, struct snd_seq_queue_tempo *tempo)
1712 {
1713     if (!snd_seq_queue_check_access(tempo->queue, client))
1714         return -EPERM;
1715     return snd_seq_queue_timer_set_tempo(tempo->queue, client, tempo);
1716 }
1717 EXPORT_SYMBOL(snd_seq_set_queue_tempo);
1718 
1719 static int snd_seq_ioctl_set_queue_tempo(struct snd_seq_client *client,
1720                      void *arg)
1721 {
1722     struct snd_seq_queue_tempo *tempo = arg;
1723     int result;
1724 
1725     result = snd_seq_set_queue_tempo(client->number, tempo);
1726     return result < 0 ? result : 0;
1727 }
1728 
1729 
1730 /* GET_QUEUE_TIMER ioctl() */
1731 static int snd_seq_ioctl_get_queue_timer(struct snd_seq_client *client,
1732                      void *arg)
1733 {
1734     struct snd_seq_queue_timer *timer = arg;
1735     struct snd_seq_queue *queue;
1736     struct snd_seq_timer *tmr;
1737 
1738     queue = queueptr(timer->queue);
1739     if (queue == NULL)
1740         return -EINVAL;
1741 
1742     mutex_lock(&queue->timer_mutex);
1743     tmr = queue->timer;
1744     memset(timer, 0, sizeof(*timer));
1745     timer->queue = queue->queue;
1746 
1747     timer->type = tmr->type;
1748     if (tmr->type == SNDRV_SEQ_TIMER_ALSA) {
1749         timer->u.alsa.id = tmr->alsa_id;
1750         timer->u.alsa.resolution = tmr->preferred_resolution;
1751     }
1752     mutex_unlock(&queue->timer_mutex);
1753     queuefree(queue);
1754     
1755     return 0;
1756 }
1757 
1758 
1759 /* SET_QUEUE_TIMER ioctl() */
1760 static int snd_seq_ioctl_set_queue_timer(struct snd_seq_client *client,
1761                      void *arg)
1762 {
1763     struct snd_seq_queue_timer *timer = arg;
1764     int result = 0;
1765 
1766     if (timer->type != SNDRV_SEQ_TIMER_ALSA)
1767         return -EINVAL;
1768 
1769     if (snd_seq_queue_check_access(timer->queue, client->number)) {
1770         struct snd_seq_queue *q;
1771         struct snd_seq_timer *tmr;
1772 
1773         q = queueptr(timer->queue);
1774         if (q == NULL)
1775             return -ENXIO;
1776         mutex_lock(&q->timer_mutex);
1777         tmr = q->timer;
1778         snd_seq_queue_timer_close(timer->queue);
1779         tmr->type = timer->type;
1780         if (tmr->type == SNDRV_SEQ_TIMER_ALSA) {
1781             tmr->alsa_id = timer->u.alsa.id;
1782             tmr->preferred_resolution = timer->u.alsa.resolution;
1783         }
1784         result = snd_seq_queue_timer_open(timer->queue);
1785         mutex_unlock(&q->timer_mutex);
1786         queuefree(q);
1787     } else {
1788         return -EPERM;
1789     }   
1790 
1791     return result;
1792 }
1793 
1794 
1795 /* GET_QUEUE_CLIENT ioctl() */
1796 static int snd_seq_ioctl_get_queue_client(struct snd_seq_client *client,
1797                       void *arg)
1798 {
1799     struct snd_seq_queue_client *info = arg;
1800     int used;
1801 
1802     used = snd_seq_queue_is_used(info->queue, client->number);
1803     if (used < 0)
1804         return -EINVAL;
1805     info->used = used;
1806     info->client = client->number;
1807 
1808     return 0;
1809 }
1810 
1811 
1812 /* SET_QUEUE_CLIENT ioctl() */
1813 static int snd_seq_ioctl_set_queue_client(struct snd_seq_client *client,
1814                       void *arg)
1815 {
1816     struct snd_seq_queue_client *info = arg;
1817     int err;
1818 
1819     if (info->used >= 0) {
1820         err = snd_seq_queue_use(info->queue, client->number, info->used);
1821         if (err < 0)
1822             return err;
1823     }
1824 
1825     return snd_seq_ioctl_get_queue_client(client, arg);
1826 }
1827 
1828 
1829 /* GET_CLIENT_POOL ioctl() */
1830 static int snd_seq_ioctl_get_client_pool(struct snd_seq_client *client,
1831                      void *arg)
1832 {
1833     struct snd_seq_client_pool *info = arg;
1834     struct snd_seq_client *cptr;
1835 
1836     cptr = snd_seq_client_use_ptr(info->client);
1837     if (cptr == NULL)
1838         return -ENOENT;
1839     memset(info, 0, sizeof(*info));
1840     info->client = cptr->number;
1841     info->output_pool = cptr->pool->size;
1842     info->output_room = cptr->pool->room;
1843     info->output_free = info->output_pool;
1844     info->output_free = snd_seq_unused_cells(cptr->pool);
1845     if (cptr->type == USER_CLIENT) {
1846         info->input_pool = cptr->data.user.fifo_pool_size;
1847         info->input_free = info->input_pool;
1848         info->input_free = snd_seq_fifo_unused_cells(cptr->data.user.fifo);
1849     } else {
1850         info->input_pool = 0;
1851         info->input_free = 0;
1852     }
1853     snd_seq_client_unlock(cptr);
1854     
1855     return 0;
1856 }
1857 
1858 /* SET_CLIENT_POOL ioctl() */
1859 static int snd_seq_ioctl_set_client_pool(struct snd_seq_client *client,
1860                      void *arg)
1861 {
1862     struct snd_seq_client_pool *info = arg;
1863     int rc;
1864 
1865     if (client->number != info->client)
1866         return -EINVAL; /* can't change other clients */
1867 
1868     if (info->output_pool >= 1 && info->output_pool <= SNDRV_SEQ_MAX_EVENTS &&
1869         (! snd_seq_write_pool_allocated(client) ||
1870          info->output_pool != client->pool->size)) {
1871         if (snd_seq_write_pool_allocated(client)) {
1872             /* is the pool in use? */
1873             if (atomic_read(&client->pool->counter))
1874                 return -EBUSY;
1875             /* remove all existing cells */
1876             snd_seq_pool_mark_closing(client->pool);
1877             snd_seq_pool_done(client->pool);
1878         }
1879         client->pool->size = info->output_pool;
1880         rc = snd_seq_pool_init(client->pool);
1881         if (rc < 0)
1882             return rc;
1883     }
1884     if (client->type == USER_CLIENT && client->data.user.fifo != NULL &&
1885         info->input_pool >= 1 &&
1886         info->input_pool <= SNDRV_SEQ_MAX_CLIENT_EVENTS &&
1887         info->input_pool != client->data.user.fifo_pool_size) {
1888         /* change pool size */
1889         rc = snd_seq_fifo_resize(client->data.user.fifo, info->input_pool);
1890         if (rc < 0)
1891             return rc;
1892         client->data.user.fifo_pool_size = info->input_pool;
1893     }
1894     if (info->output_room >= 1 &&
1895         info->output_room <= client->pool->size) {
1896         client->pool->room  = info->output_room;
1897     }
1898 
1899     return snd_seq_ioctl_get_client_pool(client, arg);
1900 }
1901 
1902 
1903 /* REMOVE_EVENTS ioctl() */
1904 static int snd_seq_ioctl_remove_events(struct snd_seq_client *client,
1905                        void *arg)
1906 {
1907     struct snd_seq_remove_events *info = arg;
1908 
1909     /*
1910      * Input mostly not implemented XXX.
1911      */
1912     if (info->remove_mode & SNDRV_SEQ_REMOVE_INPUT) {
1913         /*
1914          * No restrictions so for a user client we can clear
1915          * the whole fifo
1916          */
1917         if (client->type == USER_CLIENT && client->data.user.fifo)
1918             snd_seq_fifo_clear(client->data.user.fifo);
1919     }
1920 
1921     if (info->remove_mode & SNDRV_SEQ_REMOVE_OUTPUT)
1922         snd_seq_queue_remove_cells(client->number, info);
1923 
1924     return 0;
1925 }
1926 
1927 
1928 /*
1929  * get subscription info
1930  */
1931 static int snd_seq_ioctl_get_subscription(struct snd_seq_client *client,
1932                       void *arg)
1933 {
1934     struct snd_seq_port_subscribe *subs = arg;
1935     int result;
1936     struct snd_seq_client *sender = NULL;
1937     struct snd_seq_client_port *sport = NULL;
1938 
1939     result = -EINVAL;
1940     sender = snd_seq_client_use_ptr(subs->sender.client);
1941     if (!sender)
1942         goto __end;
1943     sport = snd_seq_port_use_ptr(sender, subs->sender.port);
1944     if (!sport)
1945         goto __end;
1946     result = snd_seq_port_get_subscription(&sport->c_src, &subs->dest,
1947                            subs);
1948       __end:
1949         if (sport)
1950         snd_seq_port_unlock(sport);
1951     if (sender)
1952         snd_seq_client_unlock(sender);
1953 
1954     return result;
1955 }
1956 
1957 
1958 /*
1959  * get subscription info - check only its presence
1960  */
1961 static int snd_seq_ioctl_query_subs(struct snd_seq_client *client, void *arg)
1962 {
1963     struct snd_seq_query_subs *subs = arg;
1964     int result = -ENXIO;
1965     struct snd_seq_client *cptr = NULL;
1966     struct snd_seq_client_port *port = NULL;
1967     struct snd_seq_port_subs_info *group;
1968     struct list_head *p;
1969     int i;
1970 
1971     cptr = snd_seq_client_use_ptr(subs->root.client);
1972     if (!cptr)
1973         goto __end;
1974     port = snd_seq_port_use_ptr(cptr, subs->root.port);
1975     if (!port)
1976         goto __end;
1977 
1978     switch (subs->type) {
1979     case SNDRV_SEQ_QUERY_SUBS_READ:
1980         group = &port->c_src;
1981         break;
1982     case SNDRV_SEQ_QUERY_SUBS_WRITE:
1983         group = &port->c_dest;
1984         break;
1985     default:
1986         goto __end;
1987     }
1988 
1989     down_read(&group->list_mutex);
1990     /* search for the subscriber */
1991     subs->num_subs = group->count;
1992     i = 0;
1993     result = -ENOENT;
1994     list_for_each(p, &group->list_head) {
1995         if (i++ == subs->index) {
1996             /* found! */
1997             struct snd_seq_subscribers *s;
1998             if (subs->type == SNDRV_SEQ_QUERY_SUBS_READ) {
1999                 s = list_entry(p, struct snd_seq_subscribers, src_list);
2000                 subs->addr = s->info.dest;
2001             } else {
2002                 s = list_entry(p, struct snd_seq_subscribers, dest_list);
2003                 subs->addr = s->info.sender;
2004             }
2005             subs->flags = s->info.flags;
2006             subs->queue = s->info.queue;
2007             result = 0;
2008             break;
2009         }
2010     }
2011     up_read(&group->list_mutex);
2012 
2013       __end:
2014     if (port)
2015         snd_seq_port_unlock(port);
2016     if (cptr)
2017         snd_seq_client_unlock(cptr);
2018 
2019     return result;
2020 }
2021 
2022 
2023 /*
2024  * query next client
2025  */
2026 static int snd_seq_ioctl_query_next_client(struct snd_seq_client *client,
2027                        void *arg)
2028 {
2029     struct snd_seq_client_info *info = arg;
2030     struct snd_seq_client *cptr = NULL;
2031 
2032     /* search for next client */
2033     if (info->client < INT_MAX)
2034         info->client++;
2035     if (info->client < 0)
2036         info->client = 0;
2037     for (; info->client < SNDRV_SEQ_MAX_CLIENTS; info->client++) {
2038         cptr = snd_seq_client_use_ptr(info->client);
2039         if (cptr)
2040             break; /* found */
2041     }
2042     if (cptr == NULL)
2043         return -ENOENT;
2044 
2045     get_client_info(cptr, info);
2046     snd_seq_client_unlock(cptr);
2047 
2048     return 0;
2049 }
2050 
2051 /* 
2052  * query next port
2053  */
2054 static int snd_seq_ioctl_query_next_port(struct snd_seq_client *client,
2055                      void *arg)
2056 {
2057     struct snd_seq_port_info *info = arg;
2058     struct snd_seq_client *cptr;
2059     struct snd_seq_client_port *port = NULL;
2060 
2061     cptr = snd_seq_client_use_ptr(info->addr.client);
2062     if (cptr == NULL)
2063         return -ENXIO;
2064 
2065     /* search for next port */
2066     info->addr.port++;
2067     port = snd_seq_port_query_nearest(cptr, info);
2068     if (port == NULL) {
2069         snd_seq_client_unlock(cptr);
2070         return -ENOENT;
2071     }
2072 
2073     /* get port info */
2074     info->addr = port->addr;
2075     snd_seq_get_port_info(port, info);
2076     snd_seq_port_unlock(port);
2077     snd_seq_client_unlock(cptr);
2078 
2079     return 0;
2080 }
2081 
2082 /* -------------------------------------------------------- */
2083 
2084 static const struct ioctl_handler {
2085     unsigned int cmd;
2086     int (*func)(struct snd_seq_client *client, void *arg);
2087 } ioctl_handlers[] = {
2088     { SNDRV_SEQ_IOCTL_PVERSION, snd_seq_ioctl_pversion },
2089     { SNDRV_SEQ_IOCTL_CLIENT_ID, snd_seq_ioctl_client_id },
2090     { SNDRV_SEQ_IOCTL_SYSTEM_INFO, snd_seq_ioctl_system_info },
2091     { SNDRV_SEQ_IOCTL_RUNNING_MODE, snd_seq_ioctl_running_mode },
2092     { SNDRV_SEQ_IOCTL_GET_CLIENT_INFO, snd_seq_ioctl_get_client_info },
2093     { SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, snd_seq_ioctl_set_client_info },
2094     { SNDRV_SEQ_IOCTL_CREATE_PORT, snd_seq_ioctl_create_port },
2095     { SNDRV_SEQ_IOCTL_DELETE_PORT, snd_seq_ioctl_delete_port },
2096     { SNDRV_SEQ_IOCTL_GET_PORT_INFO, snd_seq_ioctl_get_port_info },
2097     { SNDRV_SEQ_IOCTL_SET_PORT_INFO, snd_seq_ioctl_set_port_info },
2098     { SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, snd_seq_ioctl_subscribe_port },
2099     { SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, snd_seq_ioctl_unsubscribe_port },
2100     { SNDRV_SEQ_IOCTL_CREATE_QUEUE, snd_seq_ioctl_create_queue },
2101     { SNDRV_SEQ_IOCTL_DELETE_QUEUE, snd_seq_ioctl_delete_queue },
2102     { SNDRV_SEQ_IOCTL_GET_QUEUE_INFO, snd_seq_ioctl_get_queue_info },
2103     { SNDRV_SEQ_IOCTL_SET_QUEUE_INFO, snd_seq_ioctl_set_queue_info },
2104     { SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE, snd_seq_ioctl_get_named_queue },
2105     { SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS, snd_seq_ioctl_get_queue_status },
2106     { SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO, snd_seq_ioctl_get_queue_tempo },
2107     { SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO, snd_seq_ioctl_set_queue_tempo },
2108     { SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER, snd_seq_ioctl_get_queue_timer },
2109     { SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER, snd_seq_ioctl_set_queue_timer },
2110     { SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT, snd_seq_ioctl_get_queue_client },
2111     { SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT, snd_seq_ioctl_set_queue_client },
2112     { SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, snd_seq_ioctl_get_client_pool },
2113     { SNDRV_SEQ_IOCTL_SET_CLIENT_POOL, snd_seq_ioctl_set_client_pool },
2114     { SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION, snd_seq_ioctl_get_subscription },
2115     { SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT, snd_seq_ioctl_query_next_client },
2116     { SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT, snd_seq_ioctl_query_next_port },
2117     { SNDRV_SEQ_IOCTL_REMOVE_EVENTS, snd_seq_ioctl_remove_events },
2118     { SNDRV_SEQ_IOCTL_QUERY_SUBS, snd_seq_ioctl_query_subs },
2119     { 0, NULL },
2120 };
2121 
2122 static long snd_seq_ioctl(struct file *file, unsigned int cmd,
2123               unsigned long arg)
2124 {
2125     struct snd_seq_client *client = file->private_data;
2126     /* To use kernel stack for ioctl data. */
2127     union {
2128         int pversion;
2129         int client_id;
2130         struct snd_seq_system_info  system_info;
2131         struct snd_seq_running_info running_info;
2132         struct snd_seq_client_info  client_info;
2133         struct snd_seq_port_info    port_info;
2134         struct snd_seq_port_subscribe   port_subscribe;
2135         struct snd_seq_queue_info   queue_info;
2136         struct snd_seq_queue_status queue_status;
2137         struct snd_seq_queue_tempo  tempo;
2138         struct snd_seq_queue_timer  queue_timer;
2139         struct snd_seq_queue_client queue_client;
2140         struct snd_seq_client_pool  client_pool;
2141         struct snd_seq_remove_events    remove_events;
2142         struct snd_seq_query_subs   query_subs;
2143     } buf;
2144     const struct ioctl_handler *handler;
2145     unsigned long size;
2146     int err;
2147 
2148     if (snd_BUG_ON(!client))
2149         return -ENXIO;
2150 
2151     for (handler = ioctl_handlers; handler->cmd > 0; ++handler) {
2152         if (handler->cmd == cmd)
2153             break;
2154     }
2155     if (handler->cmd == 0)
2156         return -ENOTTY;
2157 
2158     memset(&buf, 0, sizeof(buf));
2159 
2160     /*
2161      * All of ioctl commands for ALSA sequencer get an argument of size
2162      * within 13 bits. We can safely pick up the size from the command.
2163      */
2164     size = _IOC_SIZE(handler->cmd);
2165     if (handler->cmd & IOC_IN) {
2166         if (copy_from_user(&buf, (const void __user *)arg, size))
2167             return -EFAULT;
2168     }
2169 
2170     mutex_lock(&client->ioctl_mutex);
2171     err = handler->func(client, &buf);
2172     mutex_unlock(&client->ioctl_mutex);
2173     if (err >= 0) {
2174         /* Some commands includes a bug in 'dir' field. */
2175         if (handler->cmd == SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT ||
2176             handler->cmd == SNDRV_SEQ_IOCTL_SET_CLIENT_POOL ||
2177             (handler->cmd & IOC_OUT))
2178             if (copy_to_user((void __user *)arg, &buf, size))
2179                 return -EFAULT;
2180     }
2181 
2182     return err;
2183 }
2184 
2185 #ifdef CONFIG_COMPAT
2186 #include "seq_compat.c"
2187 #else
2188 #define snd_seq_ioctl_compat    NULL
2189 #endif
2190 
2191 /* -------------------------------------------------------- */
2192 
2193 
2194 /* exported to kernel modules */
2195 int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
2196                  const char *name_fmt, ...)
2197 {
2198     struct snd_seq_client *client;
2199     va_list args;
2200 
2201     if (snd_BUG_ON(in_interrupt()))
2202         return -EBUSY;
2203 
2204     if (card && client_index >= SNDRV_SEQ_CLIENTS_PER_CARD)
2205         return -EINVAL;
2206     if (card == NULL && client_index >= SNDRV_SEQ_GLOBAL_CLIENTS)
2207         return -EINVAL;
2208 
2209     mutex_lock(&register_mutex);
2210 
2211     if (card) {
2212         client_index += SNDRV_SEQ_GLOBAL_CLIENTS
2213             + card->number * SNDRV_SEQ_CLIENTS_PER_CARD;
2214         if (client_index >= SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN)
2215             client_index = -1;
2216     }
2217 
2218     /* empty write queue as default */
2219     client = seq_create_client1(client_index, 0);
2220     if (client == NULL) {
2221         mutex_unlock(&register_mutex);
2222         return -EBUSY;  /* failure code */
2223     }
2224     usage_alloc(&client_usage, 1);
2225 
2226     client->accept_input = 1;
2227     client->accept_output = 1;
2228     client->data.kernel.card = card;
2229         
2230     va_start(args, name_fmt);
2231     vsnprintf(client->name, sizeof(client->name), name_fmt, args);
2232     va_end(args);
2233 
2234     client->type = KERNEL_CLIENT;
2235     mutex_unlock(&register_mutex);
2236 
2237     /* make others aware this new client */
2238     snd_seq_system_client_ev_client_start(client->number);
2239     
2240     /* return client number to caller */
2241     return client->number;
2242 }
2243 EXPORT_SYMBOL(snd_seq_create_kernel_client);
2244 
2245 /* exported to kernel modules */
2246 int snd_seq_delete_kernel_client(int client)
2247 {
2248     struct snd_seq_client *ptr;
2249 
2250     if (snd_BUG_ON(in_interrupt()))
2251         return -EBUSY;
2252 
2253     ptr = clientptr(client);
2254     if (ptr == NULL)
2255         return -EINVAL;
2256 
2257     seq_free_client(ptr);
2258     kfree(ptr);
2259     return 0;
2260 }
2261 EXPORT_SYMBOL(snd_seq_delete_kernel_client);
2262 
2263 /*
2264  * exported, called by kernel clients to enqueue events (w/o blocking)
2265  *
2266  * RETURN VALUE: zero if succeed, negative if error
2267  */
2268 int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev,
2269                   struct file *file, bool blocking)
2270 {
2271     struct snd_seq_client *cptr;
2272     int result;
2273 
2274     if (snd_BUG_ON(!ev))
2275         return -EINVAL;
2276 
2277     if (ev->type == SNDRV_SEQ_EVENT_NONE)
2278         return 0; /* ignore this */
2279     if (ev->type == SNDRV_SEQ_EVENT_KERNEL_ERROR)
2280         return -EINVAL; /* quoted events can't be enqueued */
2281 
2282     /* fill in client number */
2283     ev->source.client = client;
2284 
2285     if (check_event_type_and_length(ev))
2286         return -EINVAL;
2287 
2288     cptr = snd_seq_client_use_ptr(client);
2289     if (cptr == NULL)
2290         return -EINVAL;
2291     
2292     if (!cptr->accept_output) {
2293         result = -EPERM;
2294     } else { /* send it */
2295         mutex_lock(&cptr->ioctl_mutex);
2296         result = snd_seq_client_enqueue_event(cptr, ev, file, blocking,
2297                               false, 0,
2298                               &cptr->ioctl_mutex);
2299         mutex_unlock(&cptr->ioctl_mutex);
2300     }
2301 
2302     snd_seq_client_unlock(cptr);
2303     return result;
2304 }
2305 EXPORT_SYMBOL(snd_seq_kernel_client_enqueue);
2306 
2307 /* 
2308  * exported, called by kernel clients to dispatch events directly to other
2309  * clients, bypassing the queues.  Event time-stamp will be updated.
2310  *
2311  * RETURN VALUE: negative = delivery failed,
2312  *       zero, or positive: the number of delivered events
2313  */
2314 int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev,
2315                    int atomic, int hop)
2316 {
2317     struct snd_seq_client *cptr;
2318     int result;
2319 
2320     if (snd_BUG_ON(!ev))
2321         return -EINVAL;
2322 
2323     /* fill in client number */
2324     ev->queue = SNDRV_SEQ_QUEUE_DIRECT;
2325     ev->source.client = client;
2326 
2327     if (check_event_type_and_length(ev))
2328         return -EINVAL;
2329 
2330     cptr = snd_seq_client_use_ptr(client);
2331     if (cptr == NULL)
2332         return -EINVAL;
2333 
2334     if (!cptr->accept_output)
2335         result = -EPERM;
2336     else
2337         result = snd_seq_deliver_event(cptr, ev, atomic, hop);
2338 
2339     snd_seq_client_unlock(cptr);
2340     return result;
2341 }
2342 EXPORT_SYMBOL(snd_seq_kernel_client_dispatch);
2343 
2344 /**
2345  * snd_seq_kernel_client_ctl - operate a command for a client with data in
2346  *                 kernel space.
2347  * @clientid:   A numerical ID for a client.
2348  * @cmd:    An ioctl(2) command for ALSA sequencer operation.
2349  * @arg:    A pointer to data in kernel space.
2350  *
2351  * Against its name, both kernel/application client can be handled by this
2352  * kernel API. A pointer of 'arg' argument should be in kernel space.
2353  *
2354  * Return: 0 at success. Negative error code at failure.
2355  */
2356 int snd_seq_kernel_client_ctl(int clientid, unsigned int cmd, void *arg)
2357 {
2358     const struct ioctl_handler *handler;
2359     struct snd_seq_client *client;
2360 
2361     client = clientptr(clientid);
2362     if (client == NULL)
2363         return -ENXIO;
2364 
2365     for (handler = ioctl_handlers; handler->cmd > 0; ++handler) {
2366         if (handler->cmd == cmd)
2367             return handler->func(client, arg);
2368     }
2369 
2370     pr_debug("ALSA: seq unknown ioctl() 0x%x (type='%c', number=0x%02x)\n",
2371          cmd, _IOC_TYPE(cmd), _IOC_NR(cmd));
2372     return -ENOTTY;
2373 }
2374 EXPORT_SYMBOL(snd_seq_kernel_client_ctl);
2375 
2376 /* exported (for OSS emulator) */
2377 int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table *wait)
2378 {
2379     struct snd_seq_client *client;
2380 
2381     client = clientptr(clientid);
2382     if (client == NULL)
2383         return -ENXIO;
2384 
2385     if (! snd_seq_write_pool_allocated(client))
2386         return 1;
2387     if (snd_seq_pool_poll_wait(client->pool, file, wait))
2388         return 1;
2389     return 0;
2390 }
2391 EXPORT_SYMBOL(snd_seq_kernel_client_write_poll);
2392 
2393 /*---------------------------------------------------------------------------*/
2394 
2395 #ifdef CONFIG_SND_PROC_FS
2396 /*
2397  *  /proc interface
2398  */
2399 static void snd_seq_info_dump_subscribers(struct snd_info_buffer *buffer,
2400                       struct snd_seq_port_subs_info *group,
2401                       int is_src, char *msg)
2402 {
2403     struct list_head *p;
2404     struct snd_seq_subscribers *s;
2405     int count = 0;
2406 
2407     down_read(&group->list_mutex);
2408     if (list_empty(&group->list_head)) {
2409         up_read(&group->list_mutex);
2410         return;
2411     }
2412     snd_iprintf(buffer, msg);
2413     list_for_each(p, &group->list_head) {
2414         if (is_src)
2415             s = list_entry(p, struct snd_seq_subscribers, src_list);
2416         else
2417             s = list_entry(p, struct snd_seq_subscribers, dest_list);
2418         if (count++)
2419             snd_iprintf(buffer, ", ");
2420         snd_iprintf(buffer, "%d:%d",
2421                 is_src ? s->info.dest.client : s->info.sender.client,
2422                 is_src ? s->info.dest.port : s->info.sender.port);
2423         if (s->info.flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP)
2424             snd_iprintf(buffer, "[%c:%d]", ((s->info.flags & SNDRV_SEQ_PORT_SUBS_TIME_REAL) ? 'r' : 't'), s->info.queue);
2425         if (group->exclusive)
2426             snd_iprintf(buffer, "[ex]");
2427     }
2428     up_read(&group->list_mutex);
2429     snd_iprintf(buffer, "\n");
2430 }
2431 
2432 #define FLAG_PERM_RD(perm) ((perm) & SNDRV_SEQ_PORT_CAP_READ ? ((perm) & SNDRV_SEQ_PORT_CAP_SUBS_READ ? 'R' : 'r') : '-')
2433 #define FLAG_PERM_WR(perm) ((perm) & SNDRV_SEQ_PORT_CAP_WRITE ? ((perm) & SNDRV_SEQ_PORT_CAP_SUBS_WRITE ? 'W' : 'w') : '-')
2434 #define FLAG_PERM_EX(perm) ((perm) & SNDRV_SEQ_PORT_CAP_NO_EXPORT ? '-' : 'e')
2435 
2436 #define FLAG_PERM_DUPLEX(perm) ((perm) & SNDRV_SEQ_PORT_CAP_DUPLEX ? 'X' : '-')
2437 
2438 static void snd_seq_info_dump_ports(struct snd_info_buffer *buffer,
2439                     struct snd_seq_client *client)
2440 {
2441     struct snd_seq_client_port *p;
2442 
2443     mutex_lock(&client->ports_mutex);
2444     list_for_each_entry(p, &client->ports_list_head, list) {
2445         snd_iprintf(buffer, "  Port %3d : \"%s\" (%c%c%c%c)\n",
2446                 p->addr.port, p->name,
2447                 FLAG_PERM_RD(p->capability),
2448                 FLAG_PERM_WR(p->capability),
2449                 FLAG_PERM_EX(p->capability),
2450                 FLAG_PERM_DUPLEX(p->capability));
2451         snd_seq_info_dump_subscribers(buffer, &p->c_src, 1, "    Connecting To: ");
2452         snd_seq_info_dump_subscribers(buffer, &p->c_dest, 0, "    Connected From: ");
2453     }
2454     mutex_unlock(&client->ports_mutex);
2455 }
2456 
2457 
2458 /* exported to seq_info.c */
2459 void snd_seq_info_clients_read(struct snd_info_entry *entry, 
2460                    struct snd_info_buffer *buffer)
2461 {
2462     int c;
2463     struct snd_seq_client *client;
2464 
2465     snd_iprintf(buffer, "Client info\n");
2466     snd_iprintf(buffer, "  cur  clients : %d\n", client_usage.cur);
2467     snd_iprintf(buffer, "  peak clients : %d\n", client_usage.peak);
2468     snd_iprintf(buffer, "  max  clients : %d\n", SNDRV_SEQ_MAX_CLIENTS);
2469     snd_iprintf(buffer, "\n");
2470 
2471     /* list the client table */
2472     for (c = 0; c < SNDRV_SEQ_MAX_CLIENTS; c++) {
2473         client = snd_seq_client_use_ptr(c);
2474         if (client == NULL)
2475             continue;
2476         if (client->type == NO_CLIENT) {
2477             snd_seq_client_unlock(client);
2478             continue;
2479         }
2480 
2481         snd_iprintf(buffer, "Client %3d : \"%s\" [%s]\n",
2482                 c, client->name,
2483                 client->type == USER_CLIENT ? "User" : "Kernel");
2484         snd_seq_info_dump_ports(buffer, client);
2485         if (snd_seq_write_pool_allocated(client)) {
2486             snd_iprintf(buffer, "  Output pool :\n");
2487             snd_seq_info_pool(buffer, client->pool, "    ");
2488         }
2489         if (client->type == USER_CLIENT && client->data.user.fifo &&
2490             client->data.user.fifo->pool) {
2491             snd_iprintf(buffer, "  Input pool :\n");
2492             snd_seq_info_pool(buffer, client->data.user.fifo->pool, "    ");
2493         }
2494         snd_seq_client_unlock(client);
2495     }
2496 }
2497 #endif /* CONFIG_SND_PROC_FS */
2498 
2499 /*---------------------------------------------------------------------------*/
2500 
2501 
2502 /*
2503  *  REGISTRATION PART
2504  */
2505 
2506 static const struct file_operations snd_seq_f_ops =
2507 {
2508     .owner =    THIS_MODULE,
2509     .read =     snd_seq_read,
2510     .write =    snd_seq_write,
2511     .open =     snd_seq_open,
2512     .release =  snd_seq_release,
2513     .llseek =   no_llseek,
2514     .poll =     snd_seq_poll,
2515     .unlocked_ioctl =   snd_seq_ioctl,
2516     .compat_ioctl = snd_seq_ioctl_compat,
2517 };
2518 
2519 static struct device seq_dev;
2520 
2521 /* 
2522  * register sequencer device 
2523  */
2524 int __init snd_sequencer_device_init(void)
2525 {
2526     int err;
2527 
2528     snd_device_initialize(&seq_dev, NULL);
2529     dev_set_name(&seq_dev, "seq");
2530 
2531     mutex_lock(&register_mutex);
2532     err = snd_register_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0,
2533                   &snd_seq_f_ops, NULL, &seq_dev);
2534     mutex_unlock(&register_mutex);
2535     if (err < 0) {
2536         put_device(&seq_dev);
2537         return err;
2538     }
2539     
2540     return 0;
2541 }
2542 
2543 
2544 
2545 /* 
2546  * unregister sequencer device 
2547  */
2548 void snd_sequencer_device_done(void)
2549 {
2550     snd_unregister_device(&seq_dev);
2551     put_device(&seq_dev);
2552 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!