Changeset 642

Timestamp:

Jan 8, 2021, 9:57:26 AM (5 years ago)

Author:

Paul Smedley

Message:

Update code to linux 5.10.5 level

Location:

GPL/branches/uniaud32-next/alsa-kernel

Files:

• core/pcm_native.c (modified) (1 diff)
• core/rawmidi.c (modified) (10 diffs)
• core/seq/seq_queue.h (modified) (1 diff)
• include/sound/version.h (modified) (1 diff)

GPL/branches/uniaud32-next/alsa-kernel/core/pcm_native.c

@@ -760 +760 @@
 
         /* clear the buffer for avoiding possible kernel info leaks */
-        if (runtime->dma_area && !substream->ops->copy_user)
-                memset(runtime->dma_area, 0, runtime->dma_bytes);
+        if (runtime->dma_area && !substream->ops->copy_user) {
+                size_t size = runtime->dma_bytes;
+
+                if (runtime->info & SNDRV_PCM_INFO_MMAP)
+                        size = PAGE_ALIGN(size);
+                memset(runtime->dma_area, 0, size);
+        }
 
         snd_pcm_timer_resolution_change(substream);

GPL/branches/uniaud32-next/alsa-kernel/core/rawmidi.c

@@ -109 +109 @@
 }
 
-static inline int snd_rawmidi_ready(struct snd_rawmidi_substream *substream)
+static inline bool __snd_rawmidi_ready(struct snd_rawmidi_runtime *runtime)
+{
+        return runtime->avail >= runtime->avail_min;
+}
+
+static bool snd_rawmidi_ready(struct snd_rawmidi_substream *substream)
 {
         struct snd_rawmidi_runtime *runtime = substream->runtime;
-
-        return runtime->avail >= runtime->avail_min;
+        unsigned long flags;
+        bool ready;
+
+        spin_lock_irqsave(&runtime->lock, flags);
+        ready = __snd_rawmidi_ready(runtime);
+        spin_unlock_irqrestore(&runtime->lock, flags);
+        return ready;
 }
 
@@ -1041 +1051 @@
                 if (runtime->event)
                         schedule_work(&runtime->event_work);
-                else if (snd_rawmidi_ready(substream))
+                else if (__snd_rawmidi_ready(runtime))
                         wake_up(&runtime->sleep);
         }
@@ -1120 +1130 @@
         while (count > 0) {
                 spin_lock_irq(&runtime->lock);
-                while (!snd_rawmidi_ready(substream)) {
+                while (!__snd_rawmidi_ready(runtime)) {
                         wait_queue_entry_t wait;
 
@@ -1137 +1147 @@
                         if (signal_pending(current))
                                 return result > 0 ? result : -ERESTARTSYS;
-                        if (!runtime->avail)
+                        spin_lock_irq(&runtime->lock);
+                        if (!runtime->avail) {
+                                spin_unlock_irq(&runtime->lock);
                                 return result > 0 ? result : -EIO;
-                        spin_lock_irq(&runtime->lock);
+                        }
                 }
                 spin_unlock_irq(&runtime->lock);
@@ -1277 +1289 @@
         substream->bytes += count;
         if (count > 0) {
-                if (runtime->drain || snd_rawmidi_ready(substream))
+                if (runtime->drain || __snd_rawmidi_ready(runtime))
                         wake_up(&runtime->sleep);
         }
@@ -1466 +1478 @@
                         if (signal_pending(current))
                                 return result > 0 ? result : -ERESTARTSYS;
-                        if (!runtime->avail && !timeout)
+                        spin_lock_irq(&runtime->lock);
+                        if (!runtime->avail && !timeout) {
+                                spin_unlock_irq(&runtime->lock);
                                 return result > 0 ? result : -EIO;
-                        spin_lock_irq(&runtime->lock);
+                        }
                 }
                 spin_unlock_irq(&runtime->lock);
@@ -1548 +1562 @@
         struct snd_rawmidi_substream *substream;
         struct snd_rawmidi_runtime *runtime;
+        unsigned long buffer_size, avail, xruns;
 
         rmidi = entry->private_data;
@@ -1566 +1581 @@
                                     pid_vnr(substream->pid));
                                 runtime = substream->runtime;
+                                spin_lock_irq(&runtime->lock);
+                                buffer_size = runtime->buffer_size;
+                                avail = runtime->avail;
+                                spin_unlock_irq(&runtime->lock);
                                 snd_iprintf(buffer,
                                     "  Mode         : %s\n"
@@ -1571 +1590 @@
                                     "  Avail        : %lu\n",
                                     runtime->oss ? "OSS compatible" : "native",
-                                    (unsigned long) runtime->buffer_size,
-                                    (unsigned long) runtime->avail);
+                                    buffer_size, avail);
                         }
                 }
@@ -1590 +1608 @@
                                             pid_vnr(substream->pid));
                                 runtime = substream->runtime;
+                                spin_lock_irq(&runtime->lock);
+                                buffer_size = runtime->buffer_size;
+                                avail = runtime->avail;
+                                xruns = runtime->xruns;
+                                spin_unlock_irq(&runtime->lock);
                                 snd_iprintf(buffer,
                                             "  Buffer size  : %lu\n"
                                             "  Avail        : %lu\n"
                                             "  Overruns     : %lu\n",
-                                            (unsigned long) runtime->buffer_size,
-                                            (unsigned long) runtime->avail,
-                                            (unsigned long) runtime->xruns);
+                                            buffer_size, avail, xruns);
                         }
                 }

GPL/branches/uniaud32-next/alsa-kernel/core/seq/seq_queue.h

@@ -27 +27 @@
         struct snd_seq_timer *timer;    /* time keeper for this queue */
         int     owner;          /* client that 'owns' the timer */
-        unsigned int    locked:1,       /* timer is only accesibble by owner if set */
-                klocked:1,      /* kernel lock (after START) */ 
-                check_again:1,
-                check_blocked:1;
+        bool    locked;         /* timer is only accesibble by owner if set */
+        bool    klocked;        /* kernel lock (after START) */
+        bool    check_again;    /* concurrent access happened during check */
+        bool    check_blocked;  /* queue being checked */
 
         unsigned int flags;             /* status flags */

GPL/branches/uniaud32-next/alsa-kernel/include/sound/version.h

@@ -1 +1 @@
 /* include/version.h */
-#define CONFIG_SND_VERSION "5.10.4"
+#define CONFIG_SND_VERSION "5.10.5"
 #define CONFIG_SND_DATE ""