replace spin_lock_irqrestore with raw_spin_lock_irqrestore

fs/procfs/fs_procfspressure.c

@@ -131,11 +131,11 @@ static int pressure_open(FAR struct file *filep, FAR const char *relpath,
       return -ENOMEM;
     }
 
-  flags = spin_lock_irqsave(&g_pressure_lock);
+  flags = raw_spin_lock_irqsave(&g_pressure_lock);
   priv->interval = CLOCK_MAX;
   filep->f_priv = priv;
   dq_addfirst(&priv->entry, &g_pressure_memory_queue);
-  spin_unlock_irqrestore(&g_pressure_lock, flags);
+  raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
   return OK;
 }
 
@@ -148,9 +148,9 @@ static int pressure_close(FAR struct file *filep)
   FAR struct pressure_file_s *priv = filep->f_priv;
   uint32_t flags;
 
-  flags = spin_lock_irqsave(&g_pressure_lock);
+  flags = raw_spin_lock_irqsave(&g_pressure_lock);
   dq_rem(&priv->entry, &g_pressure_memory_queue);
-  spin_unlock_irqrestore(&g_pressure_lock, flags);
+  raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
   fs_heap_free(priv);
   return OK;
 }
@@ -169,10 +169,10 @@ static ssize_t pressure_read(FAR struct file *filep, FAR char *buffer,
   off_t offset;
   ssize_t ret;
 
-  flags   = spin_lock_irqsave(&g_pressure_lock);
+  flags   = raw_spin_lock_irqsave(&g_pressure_lock);
   remain  = g_remaining;
   largest = g_largest;
-  spin_unlock_irqrestore(&g_pressure_lock, flags);
+  raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
 
   ret = procfs_snprintf(buf, sizeof(buf), "remaining %zu, largest:%zu\n",
                         remain, largest);
@@ -226,14 +226,14 @@ static ssize_t pressure_write(FAR struct file *filep, FAR const char *buffer,
       interval = USEC2TICK(interval);
     }
 
-  flags = spin_lock_irqsave(&g_pressure_lock);
+  flags = raw_spin_lock_irqsave(&g_pressure_lock);
 
   /* We should trigger the first event immediately */
 
   priv->lasttick  = CLOCK_MAX;
   priv->threshold = threshold;
   priv->interval  = interval;
-  spin_unlock_irqrestore(&g_pressure_lock, flags);
+  raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
   return buflen;
 }
 
@@ -248,7 +248,7 @@ static int pressure_poll(FAR struct file *filep, FAR struct pollfd *fds,
   clock_t current = clock_systime_ticks();
   uint32_t flags;
 
-  flags = spin_lock_irqsave(&g_pressure_lock);
+  flags = raw_spin_lock_irqsave(&g_pressure_lock);
   if (setup)
     {
       if (priv->fds == NULL)
@@ -265,14 +265,14 @@ static int pressure_poll(FAR struct file *filep, FAR struct pollfd *fds,
               CLOCK_MAX || current - priv->lasttick >= priv->interval))
             {
               priv->lasttick = current;
-              spin_unlock_irqrestore(&g_pressure_lock, flags);
+              raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
               poll_notify(&priv->fds, 1, POLLPRI);
               return OK;
             }
         }
       else
         {
-          spin_unlock_irqrestore(&g_pressure_lock, flags);
+          raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
           return -EBUSY;
         }
     }
@@ -282,7 +282,7 @@ static int pressure_poll(FAR struct file *filep, FAR struct pollfd *fds,
       fds->priv = NULL;
     }
 
-  spin_unlock_irqrestore(&g_pressure_lock, flags);
+  raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
   return OK;
 }
 
@@ -302,12 +302,12 @@ static int pressure_dup(FAR const struct file *oldp, FAR struct file *newp)
       return -ENOMEM;
     }
 
-  flags = spin_lock_irqsave(&g_pressure_lock);
+  flags = raw_spin_lock_irqsave(&g_pressure_lock);
   memcpy(newpriv, oldpriv, sizeof(struct pressure_file_s));
   dq_addfirst(&newpriv->entry, &g_pressure_memory_queue);
   newpriv->fds = NULL;
   newp->f_priv = newpriv;
-  spin_unlock_irqrestore(&g_pressure_lock, flags);
+  raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
   return OK;
 }
 
@@ -425,7 +425,7 @@ void mm_notify_pressure(size_t remaining, size_t largest)
   FAR dq_entry_t *tmp;
   uint32_t flags;
 
-  flags       = spin_lock_irqsave(&g_pressure_lock);
+  flags       = raw_spin_lock_irqsave(&g_pressure_lock);
   g_remaining = remaining;
   g_largest   = largest;
 
@@ -463,11 +463,11 @@ void mm_notify_pressure(size_t remaining, size_t largest)
         }
 
       pressure->lasttick = current;
-      spin_unlock_irqrestore(&g_pressure_lock, flags);
+      raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
       poll_notify(&pressure->fds, 1, POLLPRI);
-      flags = spin_lock_irqsave(&g_pressure_lock);
+      flags = raw_spin_lock_irqsave(&g_pressure_lock);
     }
 
-  spin_unlock_irqrestore(&g_pressure_lock, flags);
+  raw_spin_unlock_irqrestore(&g_pressure_lock, flags);
 }
 

fs/v9fs/virtio_9p.c

@@ -174,7 +174,7 @@ static int virtio_9p_request(FAR struct v9fs_transport_s *transport,
       vb[payload->wcount + i].len = payload->riov[i].iov_len;
     }
 
-  flags = spin_lock_irqsave(&priv->lock);
+  flags = raw_spin_lock_irqsave(&priv->lock);
   ret = virtqueue_add_buffer(vq, vb, payload->wcount, payload->rcount,
                              payload);
   if (ret < 0)
@@ -185,7 +185,7 @@ static int virtio_9p_request(FAR struct v9fs_transport_s *transport,
 
   virtqueue_kick(vq);
 out:
-  spin_unlock_irqrestore(&priv->lock, flags);
+  raw_spin_unlock_irqrestore(&priv->lock, flags);
   return ret;
 }
 

mm/iob/iob_alloc.c

@@ -79,7 +79,7 @@ static FAR struct iob_s *iob_alloc_committed(void)
    * to protect the committed list:  We disable interrupts very briefly.
    */
 
-  flags = spin_lock_irqsave(&g_iob_lock);
+  flags = raw_spin_lock_irqsave(&g_iob_lock);
 
   /* Take the I/O buffer from the head of the committed list */
 
@@ -98,7 +98,7 @@ static FAR struct iob_s *iob_alloc_committed(void)
       iob->io_pktlen = 0;    /* Total length of the packet */
     }
 
-  spin_unlock_irqrestore(&g_iob_lock, flags);
+  raw_spin_unlock_irqrestore(&g_iob_lock, flags);
   return iob;
 }
 
@@ -173,7 +173,7 @@ static FAR struct iob_s *iob_allocwait(bool throttled, unsigned int timeout)
    * we are waiting for I/O buffers to become free.
    */
 
-  flags = spin_lock_irqsave(&g_iob_lock);
+  flags = raw_spin_lock_irqsave(&g_iob_lock);
 
   /* Try to get an I/O buffer */
 
@@ -191,7 +191,7 @@ static FAR struct iob_s *iob_allocwait(bool throttled, unsigned int timeout)
           g_iob_count--;
         }
 
-      spin_unlock_irqrestore(&g_iob_lock, flags);
+      raw_spin_unlock_irqrestore(&g_iob_lock, flags);
 
       if (timeout == UINT_MAX)
         {
@@ -217,7 +217,7 @@ static FAR struct iob_s *iob_allocwait(bool throttled, unsigned int timeout)
       return iob;
     }
 
-  spin_unlock_irqrestore(&g_iob_lock, flags);
+  raw_spin_unlock_irqrestore(&g_iob_lock, flags);
   return iob;
 }
 
@@ -304,9 +304,9 @@ FAR struct iob_s *iob_tryalloc(bool throttled)
    * to protect the free list:  We disable interrupts very briefly.
    */
 
-  flags = spin_lock_irqsave(&g_iob_lock);
+  flags = raw_spin_lock_irqsave(&g_iob_lock);
   iob = iob_tryalloc_internal(throttled);
-  spin_unlock_irqrestore(&g_iob_lock, flags);
+  raw_spin_unlock_irqrestore(&g_iob_lock, flags);
   return iob;
 }
 

mm/iob/iob_alloc_qentry.c

@@ -59,7 +59,7 @@ static FAR struct iob_qentry_s *iob_alloc_qcommitted(void)
    * to protect the committed list:  We disable interrupts very briefly.
    */
 
-  flags = spin_lock_irqsave(&g_iob_lock);
+  flags = raw_spin_lock_irqsave(&g_iob_lock);
 
   /* Take the I/O buffer from the head of the committed list */
 
@@ -75,7 +75,7 @@ static FAR struct iob_qentry_s *iob_alloc_qcommitted(void)
       iobq->qe_head = NULL; /* Nothing is contained */
     }
 
-  spin_unlock_irqrestore(&g_iob_lock, flags);
+  raw_spin_unlock_irqrestore(&g_iob_lock, flags);
   return iobq;
 }
 
@@ -127,7 +127,7 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void)
    * re-enabled while we are waiting for I/O buffers to become free.
    */
 
-  flags = spin_lock_irqsave(&g_iob_lock);
+  flags = raw_spin_lock_irqsave(&g_iob_lock);
 
   /* Try to get an I/O buffer chain container. */
 
@@ -139,7 +139,7 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void)
        */
 
       g_qentry_wait++;
-      spin_unlock_irqrestore(&g_iob_lock, flags);
+      raw_spin_unlock_irqrestore(&g_iob_lock, flags);
       ret = nxsem_wait_uninterruptible(&g_qentry_sem);
       if (ret >= 0)
         {
@@ -156,7 +156,7 @@ static FAR struct iob_qentry_s *iob_allocwait_qentry(void)
       return qentry;
     }
 
-  spin_unlock_irqrestore(&g_iob_lock, flags);
+  raw_spin_unlock_irqrestore(&g_iob_lock, flags);
 
   return qentry;
 }
@@ -212,9 +212,9 @@ FAR struct iob_qentry_s *iob_tryalloc_qentry(void)
    * to protect the free list:  We disable interrupts very briefly.
    */
 
-  flags = spin_lock_irqsave(&g_iob_lock);
+  flags = raw_spin_lock_irqsave(&g_iob_lock);
   iobq = iob_tryalloc_qentry_internal();
-  spin_unlock_irqrestore(&g_iob_lock, flags);
+  raw_spin_unlock_irqrestore(&g_iob_lock, flags);
   return iobq;
 }
 

mm/iob/iob_free.c

@@ -132,7 +132,7 @@ FAR struct iob_s *iob_free(FAR struct iob_s *iob)
    * interrupts very briefly.
    */
 
-  flags = spin_lock_irqsave(&g_iob_lock);
+  flags = raw_spin_lock_irqsave(&g_iob_lock);
 
   /* Which list?  If there is a task waiting for an IOB, then put
    * the IOB on either the free list or on the committed list where
@@ -146,7 +146,7 @@ FAR struct iob_s *iob_free(FAR struct iob_s *iob)
       g_iob_count++;
       iob->io_flink   = g_iob_committed;
       g_iob_committed = iob;
-      spin_unlock_irqrestore(&g_iob_lock, flags);
+      raw_spin_unlock_irqrestore(&g_iob_lock, flags);
       nxsem_post(&g_iob_sem);
     }
 #if CONFIG_IOB_THROTTLE > 0
@@ -155,7 +155,7 @@ FAR struct iob_s *iob_free(FAR struct iob_s *iob)
       iob->io_flink   = g_iob_committed;
       g_iob_committed = iob;
       g_throttle_wait--;
-      spin_unlock_irqrestore(&g_iob_lock, flags);
+      raw_spin_unlock_irqrestore(&g_iob_lock, flags);
       nxsem_post(&g_throttle_sem);
     }
 #endif
@@ -164,7 +164,7 @@ FAR struct iob_s *iob_free(FAR struct iob_s *iob)
       g_iob_count++;
       iob->io_flink   = g_iob_freelist;
       g_iob_freelist  = iob;
-      spin_unlock_irqrestore(&g_iob_lock, flags);
+      raw_spin_unlock_irqrestore(&g_iob_lock, flags);
     }
 
   DEBUGASSERT(g_iob_count <= CONFIG_IOB_NBUFFERS);

mm/iob/iob_free_qentry.c

@@ -60,7 +60,7 @@ FAR struct iob_qentry_s *iob_free_qentry(FAR struct iob_qentry_s *iobq)
    * interrupts very briefly.
    */
 
-  flags = spin_lock_irqsave(&g_iob_lock);
+  flags = raw_spin_lock_irqsave(&g_iob_lock);
 
   /* Which list?  If there is a task waiting for an IOB chain, then put
    * the IOB chain on either the free list or on the committed list where
@@ -73,14 +73,14 @@ FAR struct iob_qentry_s *iob_free_qentry(FAR struct iob_qentry_s *iobq)
       iobq->qe_flink   = g_iob_qcommitted;
       g_iob_qcommitted = iobq;
       g_qentry_wait--;
-      spin_unlock_irqrestore(&g_iob_lock, flags);
+      raw_spin_unlock_irqrestore(&g_iob_lock, flags);
       nxsem_post(&g_qentry_sem);
     }
   else
     {
       iobq->qe_flink   = g_iob_freeqlist;
       g_iob_freeqlist  = iobq;
-      spin_unlock_irqrestore(&g_iob_lock, flags);
+      raw_spin_unlock_irqrestore(&g_iob_lock, flags);
     }
 
   /* And return the I/O buffer chain container after the one that was freed */

mm/kasan/generic.c

@@ -165,7 +165,7 @@ static void kasan_set_poison(FAR const void *addr, size_t size,
   mask = KASAN_FIRST_WORD_MASK(bit);
   size /= KASAN_SHADOW_SCALE;
 
-  flags = spin_lock_irqsave(&g_lock);
+  flags = raw_spin_lock_irqsave(&g_lock);
   while (size >= nbit)
     {
       if (poisoned)
@@ -197,7 +197,7 @@ static void kasan_set_poison(FAR const void *addr, size_t size,
         }
     }
 
-  spin_unlock_irqrestore(&g_lock, flags);
+  raw_spin_unlock_irqrestore(&g_lock, flags);
 }
 
 /****************************************************************************
@@ -231,12 +231,12 @@ void kasan_register(FAR void *addr, FAR size_t *size)
   region->begin = (uintptr_t)addr;
   region->end   = region->begin + *size;
 
-  flags = spin_lock_irqsave(&g_lock);
+  flags = raw_spin_lock_irqsave(&g_lock);
 
   DEBUGASSERT(g_region_count <= CONFIG_MM_KASAN_REGIONS);
   g_region[g_region_count++] = region;
 
-  spin_unlock_irqrestore(&g_lock, flags);
+  raw_spin_unlock_irqrestore(&g_lock, flags);
 
   kasan_start();
   kasan_poison(addr, *size);
@@ -248,7 +248,7 @@ void kasan_unregister(FAR void *addr)
   irqstate_t flags;
   size_t i;
 
-  flags = spin_lock_irqsave(&g_lock);
+  flags = raw_spin_lock_irqsave(&g_lock);
   for (i = 0; i < g_region_count; i++)
     {
       if (g_region[i]->begin == (uintptr_t)addr)
@@ -260,5 +260,5 @@ void kasan_unregister(FAR void *addr)
         }
     }
 
-  spin_unlock_irqrestore(&g_lock, flags);
+  raw_spin_unlock_irqrestore(&g_lock, flags);
 }