ALSA: seq: Relax __free() variable declarations

We used to have a variable declaration with __free() initialized with
NULL.  This was to keep the old coding style rule, but recently it's
relaxed and rather recommends to follow the new rule to declare in
place of use for __free() -- which avoids potential deadlocks or UAFs
with nested cleanups.

Although the current code has no bug, per se, let's follow the new
standard and move the declaration to the place of assignment (or
directly assign the allocated result) instead of NULL initializations.

Note that there is a remaining __free() with NULL initialization; it's
because of the non-trivial code conditionally assigning the data.

Fixes: 04a86185b785 ("ALSA: seq: Clean up queue locking with auto cleanup")
Fixes: 0869afc958a0 ("ALSA: seq: Clean up port locking with auto cleanup")
Fixes: 99e16633958b ("ALSA: seq: Use auto-cleanup for client refcounting")
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Link: https://patch.msgid.link/20251216140634.171890-7-tiwai@suse.de

diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index f9a6e497f997ccb8e730b7801ab9f801cab1e1bf..75a7a2af9d8c963d05d3f5f34cc570684bb37922 100644 (file)
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -494,9 +494,9 @@ static int check_port_perm(struct snd_seq_client_port *port, unsigned int flags)
  */
 static struct snd_seq_client *get_event_dest_client(struct snd_seq_event *event)
 {
-       struct snd_seq_client *dest __free(snd_seq_client) = NULL;
+       struct snd_seq_client *dest __free(snd_seq_client) =
+               snd_seq_client_use_ptr(event->dest.client);
 
-       dest = snd_seq_client_use_ptr(event->dest.client);
        if (dest == NULL)
                return NULL;
        if (! dest->accept_input)
@@ -565,9 +565,9 @@ static int bounce_error_event(struct snd_seq_client *client,
 static int update_timestamp_of_queue(struct snd_seq_event *event,
                                     int queue, int real_time)
 {
-       struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
+       struct snd_seq_queue *q __free(snd_seq_queue) =
+               queueptr(queue);
 
-       q = queueptr(queue);
        if (! q)
                return 0;
        event->queue = queue;
@@ -609,13 +609,13 @@ static int _snd_seq_deliver_single_event(struct snd_seq_client *client,
                                         struct snd_seq_event *event,
                                         int atomic, int hop)
 {
-       struct snd_seq_client *dest __free(snd_seq_client) = NULL;
-       struct snd_seq_client_port *dest_port __free(snd_seq_port) = NULL;
-
-       dest = get_event_dest_client(event);
+       struct snd_seq_client *dest __free(snd_seq_client) =
+               get_event_dest_client(event);
        if (dest == NULL)
                return -ENOENT;
-       dest_port = snd_seq_port_use_ptr(dest, event->dest.port);
+
+       struct snd_seq_client_port *dest_port __free(snd_seq_port) =
+               snd_seq_port_use_ptr(dest, event->dest.port);
        if (dest_port == NULL)
                return -ENOENT;
 
@@ -672,7 +672,6 @@ static int __deliver_to_subscribers(struct snd_seq_client *client,
                                    struct snd_seq_event *event,
                                    int port, int atomic, int hop)
 {
-       struct snd_seq_client_port *src_port __free(snd_seq_port) = NULL;
        struct snd_seq_subscribers *subs;
        int err, result = 0, num_ev = 0;
        union __snd_seq_event event_saved;
@@ -681,7 +680,9 @@ static int __deliver_to_subscribers(struct snd_seq_client *client,
 
        if (port < 0)
                return 0;
-       src_port = snd_seq_port_use_ptr(client, port);
+
+       struct snd_seq_client_port *src_port __free(snd_seq_port) =
+               snd_seq_port_use_ptr(client, port);
        if (!src_port)
                return 0;
 
@@ -801,13 +802,13 @@ static int snd_seq_deliver_event(struct snd_seq_client *client, struct snd_seq_e
  */
 int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop)
 {
-       struct snd_seq_client *client __free(snd_seq_client) = NULL;
        int result;
 
        if (snd_BUG_ON(!cell))
                return -EINVAL;
 
-       client = snd_seq_client_use_ptr(cell->event.source.client);
+       struct snd_seq_client *client __free(snd_seq_client) =
+               snd_seq_client_use_ptr(cell->event.source.client);
        if (client == NULL) {
                snd_seq_cell_free(cell); /* release this cell */
                return -EINVAL;
@@ -1154,10 +1155,10 @@ static int snd_seq_ioctl_system_info(struct snd_seq_client *client, void *arg)
 static int snd_seq_ioctl_running_mode(struct snd_seq_client *client, void  *arg)
 {
        struct snd_seq_running_info *info = arg;
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
-
        /* requested client number */
-       cptr = client_load_and_use_ptr(info->client);
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               client_load_and_use_ptr(info->client);
+
        if (cptr == NULL)
                return -ENOENT;         /* don't change !!! */
 
@@ -1207,10 +1208,10 @@ static int snd_seq_ioctl_get_client_info(struct snd_seq_client *client,
                                         void *arg)
 {
        struct snd_seq_client_info *client_info = arg;
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
-
        /* requested client number */
-       cptr = client_load_and_use_ptr(client_info->client);
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               client_load_and_use_ptr(client_info->client);
+
        if (cptr == NULL)
                return -ENOENT;         /* don't change !!! */
 
@@ -1344,14 +1345,14 @@ static int snd_seq_ioctl_delete_port(struct snd_seq_client *client, void *arg)
 static int snd_seq_ioctl_get_port_info(struct snd_seq_client *client, void *arg)
 {
        struct snd_seq_port_info *info = arg;
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
-       struct snd_seq_client_port *port __free(snd_seq_port) = NULL;
 
-       cptr = client_load_and_use_ptr(info->addr.client);
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               client_load_and_use_ptr(info->addr.client);
        if (cptr == NULL)
                return -ENXIO;
 
-       port = snd_seq_port_use_ptr(cptr, info->addr.port);
+       struct snd_seq_client_port *port __free(snd_seq_port) =
+               snd_seq_port_use_ptr(cptr, info->addr.port);
        if (port == NULL)
                return -ENOENT;                 /* don't change */
 
@@ -1367,11 +1368,12 @@ static int snd_seq_ioctl_get_port_info(struct snd_seq_client *client, void *arg)
 static int snd_seq_ioctl_set_port_info(struct snd_seq_client *client, void *arg)
 {
        struct snd_seq_port_info *info = arg;
-       struct snd_seq_client_port *port __free(snd_seq_port) = NULL;
 
        if (info->addr.client != client->number) /* only set our own ports ! */
                return -EPERM;
-       port = snd_seq_port_use_ptr(client, info->addr.port);
+
+       struct snd_seq_client_port *port __free(snd_seq_port) =
+               snd_seq_port_use_ptr(client, info->addr.port);
        if (port) {
                snd_seq_set_port_info(port, info);
                /* notify the change */
@@ -1444,22 +1446,22 @@ static int snd_seq_ioctl_subscribe_port(struct snd_seq_client *client,
                                        void *arg)
 {
        struct snd_seq_port_subscribe *subs = arg;
-       struct snd_seq_client *receiver __free(snd_seq_client) = NULL;
-       struct snd_seq_client *sender __free(snd_seq_client) = NULL;
-       struct snd_seq_client_port *sport __free(snd_seq_port) = NULL;
-       struct snd_seq_client_port *dport __free(snd_seq_port) = NULL;
        int result;
 
-       receiver = client_load_and_use_ptr(subs->dest.client);
+       struct snd_seq_client *receiver __free(snd_seq_client) =
+               client_load_and_use_ptr(subs->dest.client);
        if (!receiver)
                return -EINVAL;
-       sender = client_load_and_use_ptr(subs->sender.client);
+       struct snd_seq_client *sender __free(snd_seq_client) =
+               client_load_and_use_ptr(subs->sender.client);
        if (!sender)
                return -EINVAL;
-       sport = snd_seq_port_use_ptr(sender, subs->sender.port);
+       struct snd_seq_client_port *sport __free(snd_seq_port) =
+               snd_seq_port_use_ptr(sender, subs->sender.port);
        if (!sport)
                return -EINVAL;
-       dport = snd_seq_port_use_ptr(receiver, subs->dest.port);
+       struct snd_seq_client_port *dport __free(snd_seq_port) =
+               snd_seq_port_use_ptr(receiver, subs->dest.port);
        if (!dport)
                return -EINVAL;
 
@@ -1483,22 +1485,22 @@ static int snd_seq_ioctl_unsubscribe_port(struct snd_seq_client *client,
                                          void *arg)
 {
        struct snd_seq_port_subscribe *subs = arg;
-       struct snd_seq_client *receiver __free(snd_seq_client) = NULL;
-       struct snd_seq_client *sender __free(snd_seq_client) = NULL;
-       struct snd_seq_client_port *sport __free(snd_seq_port) = NULL;
-       struct snd_seq_client_port *dport __free(snd_seq_port) = NULL;
        int result;
 
-       receiver = snd_seq_client_use_ptr(subs->dest.client);
+       struct snd_seq_client *receiver __free(snd_seq_client) =
+               snd_seq_client_use_ptr(subs->dest.client);
        if (!receiver)
                return -ENXIO;
-       sender = snd_seq_client_use_ptr(subs->sender.client);
+       struct snd_seq_client *sender __free(snd_seq_client) =
+               snd_seq_client_use_ptr(subs->sender.client);
        if (!sender)
                return -ENXIO;
-       sport = snd_seq_port_use_ptr(sender, subs->sender.port);
+       struct snd_seq_client_port *sport __free(snd_seq_port) =
+               snd_seq_port_use_ptr(sender, subs->sender.port);
        if (!sport)
                return -ENXIO;
-       dport = snd_seq_port_use_ptr(receiver, subs->dest.port);
+       struct snd_seq_client_port *dport __free(snd_seq_port) =
+               snd_seq_port_use_ptr(receiver, subs->dest.port);
        if (!dport)
                return -ENXIO;
 
@@ -1518,9 +1520,9 @@ static int snd_seq_ioctl_unsubscribe_port(struct snd_seq_client *client,
 static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, void *arg)
 {
        struct snd_seq_queue_info *info = arg;
-       struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
+       struct snd_seq_queue *q __free(snd_seq_queue) =
+               snd_seq_queue_alloc(client->number, info->locked, info->flags);
 
-       q = snd_seq_queue_alloc(client->number, info->locked, info->flags);
        if (IS_ERR(q))
                return PTR_ERR(q);
 
@@ -1549,9 +1551,9 @@ static int snd_seq_ioctl_get_queue_info(struct snd_seq_client *client,
                                        void *arg)
 {
        struct snd_seq_queue_info *info = arg;
-       struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
+       struct snd_seq_queue *q __free(snd_seq_queue) =
+               queueptr(info->queue);
 
-       q = queueptr(info->queue);
        if (q == NULL)
                return -EINVAL;
 
@@ -1569,7 +1571,6 @@ static int snd_seq_ioctl_set_queue_info(struct snd_seq_client *client,
                                        void *arg)
 {
        struct snd_seq_queue_info *info = arg;
-       struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
 
        if (info->owner != client->number)
                return -EINVAL;
@@ -1584,7 +1585,8 @@ static int snd_seq_ioctl_set_queue_info(struct snd_seq_client *client,
                return -EPERM;
        }       
 
-       q = queueptr(info->queue);
+       struct snd_seq_queue *q __free(snd_seq_queue) =
+               queueptr(info->queue);
        if (! q)
                return -EINVAL;
        if (q->owner != client->number)
@@ -1599,9 +1601,9 @@ static int snd_seq_ioctl_get_named_queue(struct snd_seq_client *client,
                                         void *arg)
 {
        struct snd_seq_queue_info *info = arg;
-       struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
+       struct snd_seq_queue *q __free(snd_seq_queue) =
+               snd_seq_queue_find_name(info->name);
 
-       q = snd_seq_queue_find_name(info->name);
        if (q == NULL)
                return -EINVAL;
        info->queue = q->queue;
@@ -1616,10 +1618,10 @@ static int snd_seq_ioctl_get_queue_status(struct snd_seq_client *client,
                                          void *arg)
 {
        struct snd_seq_queue_status *status = arg;
-       struct snd_seq_queue *queue __free(snd_seq_queue) = NULL;
        struct snd_seq_timer *tmr;
+       struct snd_seq_queue *queue __free(snd_seq_queue) =
+               queueptr(status->queue);
 
-       queue = queueptr(status->queue);
        if (queue == NULL)
                return -EINVAL;
        memset(status, 0, sizeof(*status));
@@ -1644,10 +1646,10 @@ static int snd_seq_ioctl_get_queue_tempo(struct snd_seq_client *client,
                                         void *arg)
 {
        struct snd_seq_queue_tempo *tempo = arg;
-       struct snd_seq_queue *queue __free(snd_seq_queue) = NULL;
        struct snd_seq_timer *tmr;
+       struct snd_seq_queue *queue __free(snd_seq_queue) =
+               queueptr(tempo->queue);
 
-       queue = queueptr(tempo->queue);
        if (queue == NULL)
                return -EINVAL;
        memset(tempo, 0, sizeof(*tempo));
@@ -1693,10 +1695,10 @@ static int snd_seq_ioctl_get_queue_timer(struct snd_seq_client *client,
                                         void *arg)
 {
        struct snd_seq_queue_timer *timer = arg;
-       struct snd_seq_queue *queue __free(snd_seq_queue) = NULL;
        struct snd_seq_timer *tmr;
+       struct snd_seq_queue *queue __free(snd_seq_queue) =
+               queueptr(timer->queue);
 
-       queue = queueptr(timer->queue);
        if (queue == NULL)
                return -EINVAL;
 
@@ -1726,10 +1728,10 @@ static int snd_seq_ioctl_set_queue_timer(struct snd_seq_client *client,
                return -EINVAL;
 
        if (snd_seq_queue_check_access(timer->queue, client->number)) {
-               struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
                struct snd_seq_timer *tmr;
+               struct snd_seq_queue *q __free(snd_seq_queue) =
+                       queueptr(timer->queue);
 
-               q = queueptr(timer->queue);
                if (q == NULL)
                        return -ENXIO;
                guard(mutex)(&q->timer_mutex);
@@ -1788,9 +1790,9 @@ static int snd_seq_ioctl_get_client_pool(struct snd_seq_client *client,
                                         void *arg)
 {
        struct snd_seq_client_pool *info = arg;
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               client_load_and_use_ptr(info->client);
 
-       cptr = client_load_and_use_ptr(info->client);
        if (cptr == NULL)
                return -ENOENT;
        memset(info, 0, sizeof(*info));
@@ -1888,13 +1890,13 @@ static int snd_seq_ioctl_get_subscription(struct snd_seq_client *client,
                                          void *arg)
 {
        struct snd_seq_port_subscribe *subs = arg;
-       struct snd_seq_client *sender __free(snd_seq_client) = NULL;
-       struct snd_seq_client_port *sport __free(snd_seq_port) = NULL;
 
-       sender = client_load_and_use_ptr(subs->sender.client);
+       struct snd_seq_client *sender __free(snd_seq_client) =
+               client_load_and_use_ptr(subs->sender.client);
        if (!sender)
                return -EINVAL;
-       sport = snd_seq_port_use_ptr(sender, subs->sender.port);
+       struct snd_seq_client_port *sport __free(snd_seq_port) =
+               snd_seq_port_use_ptr(sender, subs->sender.port);
        if (!sport)
                return -EINVAL;
        return snd_seq_port_get_subscription(&sport->c_src, &subs->dest, subs);
@@ -1907,16 +1909,16 @@ static int snd_seq_ioctl_get_subscription(struct snd_seq_client *client,
 static int snd_seq_ioctl_query_subs(struct snd_seq_client *client, void *arg)
 {
        struct snd_seq_query_subs *subs = arg;
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
-       struct snd_seq_client_port *port __free(snd_seq_port) = NULL;
        struct snd_seq_port_subs_info *group;
        struct list_head *p;
        int i;
 
-       cptr = client_load_and_use_ptr(subs->root.client);
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               client_load_and_use_ptr(subs->root.client);
        if (!cptr)
                return -ENXIO;
-       port = snd_seq_port_use_ptr(cptr, subs->root.port);
+       struct snd_seq_client_port *port __free(snd_seq_port) =
+               snd_seq_port_use_ptr(cptr, subs->root.port);
        if (!port)
                return -ENXIO;
 
@@ -1963,7 +1965,6 @@ static int snd_seq_ioctl_query_next_client(struct snd_seq_client *client,
                                           void *arg)
 {
        struct snd_seq_client_info *info = arg;
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
 
        /* search for next client */
        if (info->client < INT_MAX)
@@ -1971,7 +1972,8 @@ static int snd_seq_ioctl_query_next_client(struct snd_seq_client *client,
        if (info->client < 0)
                info->client = 0;
        for (; info->client < SNDRV_SEQ_MAX_CLIENTS; info->client++) {
-               cptr = client_load_and_use_ptr(info->client);
+               struct snd_seq_client *cptr __free(snd_seq_client) =
+                       client_load_and_use_ptr(info->client);
                if (cptr) {
                        get_client_info(cptr, info);
                        return 0; /* found */
@@ -1987,16 +1989,16 @@ static int snd_seq_ioctl_query_next_port(struct snd_seq_client *client,
                                         void *arg)
 {
        struct snd_seq_port_info *info = arg;
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
-       struct snd_seq_client_port *port __free(snd_seq_port) = NULL;
 
-       cptr = client_load_and_use_ptr(info->addr.client);
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               client_load_and_use_ptr(info->addr.client);
        if (cptr == NULL)
                return -ENXIO;
 
        /* search for next port */
        info->addr.port++;
-       port = snd_seq_port_query_nearest(cptr, info);
+       struct snd_seq_client_port *port __free(snd_seq_port) =
+               snd_seq_port_query_nearest(cptr, info);
        if (port == NULL)
                return -ENOENT;
 
@@ -2067,7 +2069,6 @@ static int snd_seq_ioctl_client_ump_info(struct snd_seq_client *caller,
 {
        struct snd_seq_client_ump_info __user *argp =
                (struct snd_seq_client_ump_info __user *)arg;
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
        int client, type, err = 0;
        size_t size;
        void *p;
@@ -2083,7 +2084,9 @@ static int snd_seq_ioctl_client_ump_info(struct snd_seq_client *caller,
                size = sizeof(struct snd_ump_endpoint_info);
        else
                size = sizeof(struct snd_ump_block_info);
-       cptr = client_load_and_use_ptr(client);
+
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               client_load_and_use_ptr(client);
        if (!cptr)
                return -ENOENT;
 
@@ -2342,8 +2345,6 @@ EXPORT_SYMBOL(snd_seq_delete_kernel_client);
 int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev,
                                  struct file *file, bool blocking)
 {
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
-
        if (snd_BUG_ON(!ev))
                return -EINVAL;
 
@@ -2360,7 +2361,8 @@ int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev,
        if (check_event_type_and_length(ev))
                return -EINVAL;
 
-       cptr = client_load_and_use_ptr(client);
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               client_load_and_use_ptr(client);
        if (cptr == NULL)
                return -EINVAL;
        
@@ -2385,8 +2387,6 @@ EXPORT_SYMBOL(snd_seq_kernel_client_enqueue);
 int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev,
                                   int atomic, int hop)
 {
-       struct snd_seq_client *cptr __free(snd_seq_client) = NULL;
-
        if (snd_BUG_ON(!ev))
                return -EINVAL;
 
@@ -2397,7 +2397,8 @@ int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev,
        if (check_event_type_and_length(ev))
                return -EINVAL;
 
-       cptr = snd_seq_client_use_ptr(client);
+       struct snd_seq_client *cptr __free(snd_seq_client) =
+               snd_seq_client_use_ptr(client);
        if (cptr == NULL)
                return -EINVAL;
 
@@ -2450,9 +2451,9 @@ EXPORT_SYMBOL(snd_seq_kernel_client_ctl);
 /* a similar like above but taking locks; used only from OSS sequencer layer */
 int snd_seq_kernel_client_ioctl(int clientid, unsigned int cmd, void *arg)
 {
-       struct snd_seq_client *client __free(snd_seq_client) = NULL;
+       struct snd_seq_client *client __free(snd_seq_client) =
+               client_load_and_use_ptr(clientid);
 
-       client = client_load_and_use_ptr(clientid);
        if (!client)
                return -ENXIO;
        guard(mutex)(&client->ioctl_mutex);
@@ -2597,9 +2598,9 @@ void snd_seq_info_clients_read(struct snd_info_entry *entry,
 
        /* list the client table */
        for (c = 0; c < SNDRV_SEQ_MAX_CLIENTS; c++) {
-               struct snd_seq_client *client __free(snd_seq_client) = NULL;
+               struct snd_seq_client *client __free(snd_seq_client) =
+                       client_load_and_use_ptr(c);
 
-               client = client_load_and_use_ptr(c);
                if (client == NULL)
                        continue;
                if (client->type == NO_CLIENT)

diff --git a/sound/core/seq/seq_compat.c b/sound/core/seq/seq_compat.c
index 643af4c1e838669a2fe45c9ecfb4072d166c917b..260428747e337bdd2ec7e6230ec2b1660156f715 100644 (file)
--- a/sound/core/seq/seq_compat.c
+++ b/sound/core/seq/seq_compat.c
@@ -31,10 +31,10 @@ struct snd_seq_port_info32 {
 static int snd_seq_call_port_info_ioctl(struct snd_seq_client *client, unsigned int cmd,
                                        struct snd_seq_port_info32 __user *data32)
 {
-       struct snd_seq_port_info *data __free(kfree) = NULL;
        int err;
+       struct snd_seq_port_info *data __free(kfree) =
+               kmalloc(sizeof(*data), GFP_KERNEL);
 
-       data = kmalloc(sizeof(*data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
 

diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c
index de7ec7d15f23737d20593ee856221cb60de8fe3e..88e930980f16c82cbddbc6ccd1d3e87e1269a615 100644 (file)
--- a/sound/core/seq/seq_midi.c
+++ b/sound/core/seq/seq_midi.c
@@ -269,8 +269,6 @@ snd_seq_midisynth_probe(struct snd_seq_device *dev)
 {
        struct seq_midisynth_client *client;
        struct seq_midisynth *msynth, *ms;
-       struct snd_seq_port_info *port __free(kfree) = NULL;
-       struct snd_rawmidi_info *info __free(kfree) = NULL;
        struct snd_rawmidi *rmidi = dev->private_data;
        int newclient = 0;
        unsigned int p, ports;
@@ -281,7 +279,9 @@ snd_seq_midisynth_probe(struct snd_seq_device *dev)
 
        if (snd_BUG_ON(!card || device < 0 || device >= SNDRV_RAWMIDI_DEVICES))
                return -EINVAL;
-       info = kmalloc(sizeof(*info), GFP_KERNEL);
+
+       struct snd_rawmidi_info *info __free(kfree) =
+               kmalloc(sizeof(*info), GFP_KERNEL);
        if (! info)
                return -ENOMEM;
        info->device = device;
@@ -319,7 +319,9 @@ snd_seq_midisynth_probe(struct snd_seq_device *dev)
        }
 
        msynth = kcalloc(ports, sizeof(struct seq_midisynth), GFP_KERNEL);
-       port = kmalloc(sizeof(*port), GFP_KERNEL);
+
+       struct snd_seq_port_info *port __free(kfree) =
+               kmalloc(sizeof(*port), GFP_KERNEL);
        if (msynth == NULL || port == NULL)
                goto __nomem;
 

diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index 40fa379847e573d0cc619a4013f7c0a7487230cb..bbec34bba4f9983c09688e32b138768e8b16dd25 100644 (file)
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -211,14 +211,13 @@ static void clear_subscriber_list(struct snd_seq_client *client,
 
        list_for_each_safe(p, n, &grp->list_head) {
                struct snd_seq_subscribers *subs;
-               struct snd_seq_client *c __free(snd_seq_client) = NULL;
-               struct snd_seq_client_port *aport __free(snd_seq_port) = NULL;
 
                subs = get_subscriber(p, is_src);
-               if (is_src)
-                       aport = get_client_port(&subs->info.dest, &c);
-               else
-                       aport = get_client_port(&subs->info.sender, &c);
+               struct snd_seq_client *c __free(snd_seq_client) = NULL;
+               struct snd_seq_client_port *aport __free(snd_seq_port) =
+                       is_src ?
+                       get_client_port(&subs->info.dest, &c) :
+                       get_client_port(&subs->info.sender, &c);
                delete_and_unsubscribe_port(client, port, subs, is_src, false);
 
                if (!aport) {

diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c
index f5c0e401c8ae56e0d8e1d64a1a4a2d1ab5387d27..c0c5e1424c5a1cc55ac057dca413d3daae6aded0 100644 (file)
--- a/sound/core/seq/seq_queue.c
+++ b/sound/core/seq/seq_queue.c
@@ -211,8 +211,9 @@ struct snd_seq_queue *snd_seq_queue_find_name(char *name)
        int i;
 
        for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) {
-               struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
-               q = queueptr(i);
+               struct snd_seq_queue *q __free(snd_seq_queue) =
+                       queueptr(i);
+
                if (q) {
                        if (strncmp(q->name, name, sizeof(q->name)) == 0)
                                return no_free_ptr(q);
@@ -285,12 +286,13 @@ void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop)
 int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop)
 {
        int dest, err;
-       struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
 
        if (snd_BUG_ON(!cell))
                return -EINVAL;
        dest = cell->event.queue;       /* destination queue */
-       q = queueptr(dest);
+
+       struct snd_seq_queue *q __free(snd_seq_queue) =
+               queueptr(dest);
        if (q == NULL)
                return -EINVAL;
        /* handle relative time stamps, convert them into absolute */
@@ -403,10 +405,10 @@ int snd_seq_queue_set_owner(int queueid, int client, int locked)
 int snd_seq_queue_timer_open(int queueid)
 {
        int result = 0;
-       struct snd_seq_queue *queue __free(snd_seq_queue) = NULL;
        struct snd_seq_timer *tmr;
+       struct snd_seq_queue *queue __free(snd_seq_queue) =
+               queueptr(queueid);
 
-       queue = queueptr(queueid);
        if (queue == NULL)
                return -EINVAL;
        tmr = queue->timer;
@@ -423,10 +425,10 @@ int snd_seq_queue_timer_open(int queueid)
  */
 int snd_seq_queue_timer_close(int queueid)
 {
-       struct snd_seq_queue *queue __free(snd_seq_queue) = NULL;
        int result = 0;
+       struct snd_seq_queue *queue __free(snd_seq_queue) =
+               queueptr(queueid);
 
-       queue = queueptr(queueid);
        if (queue == NULL)
                return -EINVAL;
        snd_seq_timer_close(queue);
@@ -479,9 +481,9 @@ static void queue_use(struct snd_seq_queue *queue, int client, int use)
  */
 int snd_seq_queue_use(int queueid, int client, int use)
 {
-       struct snd_seq_queue *queue __free(snd_seq_queue) = NULL;
+       struct snd_seq_queue *queue __free(snd_seq_queue) =
+               queueptr(queueid);
 
-       queue = queueptr(queueid);
        if (queue == NULL)
                return -EINVAL;
        guard(mutex)(&queue->timer_mutex);
@@ -496,9 +498,9 @@ int snd_seq_queue_use(int queueid, int client, int use)
  */
 int snd_seq_queue_is_used(int queueid, int client)
 {
-       struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
+       struct snd_seq_queue *q __free(snd_seq_queue) =
+               queueptr(queueid);
 
-       q = queueptr(queueid);
        if (q == NULL)
                return -EINVAL; /* invalid queue */
        return test_bit(client, q->clients_bitmap) ? 1 : 0;
@@ -642,11 +644,11 @@ static void snd_seq_queue_process_event(struct snd_seq_queue *q,
  */
 int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop)
 {
-       struct snd_seq_queue *q __free(snd_seq_queue) = NULL;
-
        if (snd_BUG_ON(!ev))
                return -EINVAL;
-       q = queueptr(ev->data.queue.queue);
+
+       struct snd_seq_queue *q __free(snd_seq_queue) =
+               queueptr(ev->data.queue.queue);
 
        if (q == NULL)
                return -EINVAL;

diff --git a/sound/core/seq/seq_ump_client.c b/sound/core/seq/seq_ump_client.c
index a96d21981cbeecdd25d7e8fa61e60f2e162ed129..7bc18415a54034f4d188e9beaa3e5d448c3b34a2 100644 (file)
--- a/sound/core/seq/seq_ump_client.c
+++ b/sound/core/seq/seq_ump_client.c
@@ -214,13 +214,13 @@ static bool skip_group(struct seq_ump_client *client, struct snd_ump_group *grou
 static int seq_ump_group_init(struct seq_ump_client *client, int group_index)
 {
        struct snd_ump_group *group = &client->ump->groups[group_index];
-       struct snd_seq_port_info *port __free(kfree) = NULL;
        struct snd_seq_port_callback pcallbacks;
 
        if (skip_group(client, group))
                return 0;
 
-       port = kzalloc(sizeof(*port), GFP_KERNEL);
+       struct snd_seq_port_info *port __free(kfree) =
+               kzalloc(sizeof(*port), GFP_KERNEL);
        if (!port)
                return -ENOMEM;
 
@@ -243,12 +243,12 @@ static int seq_ump_group_init(struct seq_ump_client *client, int group_index)
 /* update the sequencer ports; called from notify_fb_change callback */
 static void update_port_infos(struct seq_ump_client *client)
 {
-       struct snd_seq_port_info *old __free(kfree) = NULL;
-       struct snd_seq_port_info *new __free(kfree) = NULL;
        int i, err;
 
-       old = kzalloc(sizeof(*old), GFP_KERNEL);
-       new = kzalloc(sizeof(*new), GFP_KERNEL);
+       struct snd_seq_port_info *old __free(kfree) =
+               kzalloc(sizeof(*old), GFP_KERNEL);
+       struct snd_seq_port_info *new __free(kfree) =
+               kzalloc(sizeof(*new), GFP_KERNEL);
        if (!old || !new)
                return;
 
@@ -278,12 +278,12 @@ static void update_port_infos(struct seq_ump_client *client)
 /* create a UMP Endpoint port */
 static int create_ump_endpoint_port(struct seq_ump_client *client)
 {
-       struct snd_seq_port_info *port __free(kfree) = NULL;
        struct snd_seq_port_callback pcallbacks;
        unsigned int rawmidi_info = client->ump->core.info_flags;
        int err;
 
-       port = kzalloc(sizeof(*port), GFP_KERNEL);
+       struct snd_seq_port_info *port __free(kfree) =
+               kzalloc(sizeof(*port), GFP_KERNEL);
        if (!port)
                return -ENOMEM;
 

diff --git a/sound/core/seq/seq_virmidi.c b/sound/core/seq/seq_virmidi.c
index 9e7fd4993a108595ef6591789dfedd2349ad0459..574493fbd50d0e514d99dafdd69a6ebce6509a8d 100644 (file)
--- a/sound/core/seq/seq_virmidi.c
+++ b/sound/core/seq/seq_virmidi.c
@@ -361,13 +361,13 @@ static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev)
 {
        int client;
        struct snd_seq_port_callback pcallbacks;
-       struct snd_seq_port_info *pinfo __free(kfree) = NULL;
        int err;
 
        if (rdev->client >= 0)
                return 0;
 
-       pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
+       struct snd_seq_port_info *pinfo __free(kfree) =
+               kzalloc(sizeof(*pinfo), GFP_KERNEL);
        if (!pinfo)
                return -ENOMEM;