net/usrsock: replace net_lock with usrsock_lock

remove the use of net_lock in the usrsock module and decouple it from
other network modules.

Signed-off-by: zhanghongyu <zhanghongyu@xiaomi.com>

drivers/usrsock/usrsock_dev.c

@@ -490,7 +490,7 @@ int usrsock_request(FAR struct iovec *iov, unsigned int iovcnt)
 
   /* Set outstanding request for daemon to handle. */
 
-  net_mutex_lock(&dev->devlock);
+  usrsock_mutex_timedlock(&dev->devlock, UINT_MAX);
 
   if (usrsockdev_is_opened(dev))
     {

drivers/usrsock/usrsock_rpmsg.c

@@ -100,9 +100,9 @@ static int usrsock_rpmsg_send_dns_request(FAR void *arg,
   dns->addrlen = addrlen;
   memcpy(dns + 1, addr, addrlen);
 
-  net_lock();
+  usrsock_lock();
   ret = rpmsg_send_nocopy(ept, dns, sizeof(*dns) + addrlen);
-  net_unlock();
+  usrsock_unlock();
   if (ret < 0)
     {
       rpmsg_release_tx_buffer(ept, dns);
@@ -205,7 +205,7 @@ int usrsock_request(FAR struct iovec *iov, unsigned int iovcnt)
   nxsem_get_value(&priv->wait, &ret);
   if (ret <= 0)
     {
-      net_sem_wait_uninterruptible(&priv->wait);
+      usrsock_sem_timedwait(&priv->wait, false, UINT_MAX);
       nxsem_post(&priv->wait);
     }
 

include/nuttx/net/net.h

@@ -411,30 +411,6 @@ void net_unlock(void);
 
 int net_sem_timedwait(FAR sem_t *sem, unsigned int timeout);
 
-/****************************************************************************
- * Name: net_mutex_timedlock
- *
- * Description:
- *   Atomically wait for mutex (or a timeout) while temporarily releasing
- *   the lock on the network.
- *
- *   Caution should be utilized.  Because the network lock is relinquished
- *   during the wait, there could be changes in the network state that occur
- *   before the lock is recovered.  Your design should account for this
- *   possibility.
- *
- * Input Parameters:
- *   mutex   - A reference to the mutex to be taken.
- *   timeout - The relative time to wait until a timeout is declared.
- *
- * Returned Value:
- *   Zero (OK) is returned on success; a negated errno value is returned on
- *   any failure.
- *
- ****************************************************************************/
-
-int net_mutex_timedlock(FAR mutex_t *mutex, unsigned int timeout);
-
 /****************************************************************************
  * Name: net_sem_wait
  *
@@ -457,28 +433,6 @@ int net_mutex_timedlock(FAR mutex_t *mutex, unsigned int timeout);
 
 int net_sem_wait(FAR sem_t *sem);
 
-/****************************************************************************
- * Name: net_mutex_lock
- *
- * Description:
- *   Atomically wait for mutex while temporarily releasing the network lock.
- *
- *   Caution should be utilized.  Because the network lock is relinquished
- *   during the wait, there could be changes in the network state that occur
- *   before the lock is recovered.  Your design should account for this
- *   possibility.
- *
- * Input Parameters:
- *   mutex - A reference to the mutex to be taken.
- *
- * Returned Value:
- *   Zero (OK) is returned on success; a negated errno value is returned on
- *   any failure.
- *
- ****************************************************************************/
-
-int net_mutex_lock(FAR mutex_t *mutex);
-
 /****************************************************************************
  * Name: net_sem_timedwait_uninterruptible
  *

include/nuttx/net/usrsock.h

@@ -34,8 +34,10 @@
 #include <sys/uio.h>
 #include <sys/param.h>
 
+#include <nuttx/net/net.h>
 #include <nuttx/net/netconfig.h>
 #include <nuttx/compiler.h>
+#include <nuttx/mutex.h>
 
 /****************************************************************************
  * Pre-processor Definitions
@@ -267,6 +269,121 @@ begin_packed_struct struct usrsock_message_socket_event_s
   int16_t usockid;
 } end_packed_struct;
 
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/* Global protection lock for usrsock socket */
+
+#ifdef CONFIG_NET_USRSOCK
+extern rmutex_t g_usrsock_lock;
+
+/****************************************************************************
+ * Inline Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usrsock_lock
+ *
+ * Description:
+ *   Take the global usrsock socket lock
+ *
+ ****************************************************************************/
+
+static inline_function void usrsock_lock(void)
+{
+  nxrmutex_lock(&g_usrsock_lock);
+}
+
+/****************************************************************************
+ * Name: usrsock_unlock
+ *
+ * Description:
+ *   Release the global usrsock socket lock
+ *
+ ****************************************************************************/
+
+static inline_function void usrsock_unlock(void)
+{
+  nxrmutex_unlock(&g_usrsock_lock);
+}
+
+/****************************************************************************
+ * Name: usrsock_sem_timedwait
+ *
+ * Description:
+ *   Wait for sem while temporarily releasing the usrsock lock.
+ *
+ ****************************************************************************/
+
+static inline_function int
+usrsock_sem_timedwait(FAR sem_t *sem, bool interruptible,
+                      unsigned int timeout)
+{
+  return net_sem_timedwait2(sem, interruptible, timeout, &g_usrsock_lock,
+                            NULL);
+}
+
+/****************************************************************************
+ * Name: usrsock_mutex_timedlock
+ *
+ * Description:
+ *   Atomically wait for mutex (or a timeout) while temporarily releasing
+ *   the lock on the usrsock.
+ *
+ *   Caution should be utilized.  Because the usrsock lock is relinquished
+ *   during the wait, there could be changes in the usrsock state that occur
+ *   before the lock is recovered.  Your design should account for this
+ *   possibility.
+ *
+ * Input Parameters:
+ *   mutex    - A reference to the mutex to be taken.
+ *   timeout  - The relative time to wait until a timeout is declared.
+ *   brkmutex - A reference to the mutex to be temporarily released while
+ *              waiting.
+ *
+ * Returned Value:
+ *   Zero (OK) is returned on success; a negated errno value is returned on
+ *   any failure.
+ *
+ ****************************************************************************/
+
+static inline_function int
+usrsock_mutex_timedlock(FAR mutex_t *mutex, unsigned int timeout)
+{
+  unsigned int count;
+  int          blresult;
+  int          ret;
+
+  /* Release the network lock, remembering my count.  net_breaklock will
+   * return a negated value if the caller does not hold the network lock.
+   */
+
+  blresult = nxrmutex_breaklock(&g_usrsock_lock, &count);
+
+  /* Now take the mutex, waiting if so requested. */
+
+  if (timeout != UINT_MAX)
+    {
+      ret = nxmutex_timedlock(mutex, timeout);
+    }
+  else
+    {
+      /* Wait as long as necessary to get the lock */
+
+      ret = nxmutex_lock(mutex);
+    }
+
+  /* Recover the network lock at the proper count (if we held it before) */
+
+  if (blresult >= 0)
+    {
+      nxrmutex_restorelock(&g_usrsock_lock, count);
+    }
+
+  return ret;
+}
+
 /****************************************************************************
  * Name: usrsock_iovec_get() - copy from iovec to buffer.
  ****************************************************************************/
@@ -310,5 +427,6 @@ int usrsock_request(FAR struct iovec *iov, unsigned int iovcnt);
  ****************************************************************************/
 
 void usrsock_register(void);
+#endif /* CONFIG_NET_USRSOCK */
 
 #endif /* __INCLUDE_NUTTX_NET_USRSOCK_H */

net/usrsock/usrsock_accept.c

@@ -239,7 +239,7 @@ int usrsock_accept(FAR struct socket *psock, FAR struct sockaddr *addr,
       inaddrlen = *addrlen;
     }
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -327,8 +327,8 @@ int usrsock_accept(FAR struct socket *psock, FAR struct sockaddr *addr,
 
           /* Wait for receive-avail (or abort, or timeout, or signal). */
 
-          ret = net_sem_timedwait(&state.reqstate.recvsem,
-                              _SO_TIMEOUT(conn->sconn.s_rcvtimeo));
+          ret = usrsock_sem_timedwait(&state.reqstate.recvsem, true,
+                                      _SO_TIMEOUT(conn->sconn.s_rcvtimeo));
           usrsock_teardown_data_request_callback(&state);
           if (ret < 0)
             {
@@ -344,7 +344,7 @@ int usrsock_accept(FAR struct socket *psock, FAR struct sockaddr *addr,
                 }
               else
                 {
-                  nerr("net_sem_timedwait errno: %d\n", ret);
+                  nerr("usrsock_sem_timedwait errno: %d\n", ret);
                   DEBUGPANIC();
                 }
 
@@ -401,7 +401,7 @@ int usrsock_accept(FAR struct socket *psock, FAR struct sockaddr *addr,
         {
           /* Wait for completion of request. */
 
-          net_sem_wait_uninterruptible(&state.reqstate.recvsem);
+          usrsock_sem_timedwait(&state.reqstate.recvsem, false, UINT_MAX);
           ret = state.reqstate.result;
 
           DEBUGASSERT(state.valuelen <= inaddrlen);
@@ -440,7 +440,7 @@ errout_free_conn:
   usrsock_free(newconn);
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
 
   if (addrlen)
     {

net/usrsock/usrsock_bind.c

@@ -158,7 +158,7 @@ int usrsock_bind(FAR struct socket *psock,
 
   int ret;
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -191,14 +191,14 @@ int usrsock_bind(FAR struct socket *psock,
     {
       /* Wait for completion of request. */
 
-      net_sem_wait_uninterruptible(&state.recvsem);
+      usrsock_sem_timedwait(&state.recvsem, false, UINT_MAX);
       ret = state.result;
     }
 
   usrsock_teardown_request_callback(&state);
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_close.c

@@ -130,7 +130,7 @@ int usrsock_close(FAR struct usrsock_conn_s *conn)
 
   int ret;
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -165,7 +165,7 @@ int usrsock_close(FAR struct usrsock_conn_s *conn)
     {
       /* Wait for completion of request. */
 
-      net_sem_wait_uninterruptible(&state.recvsem);
+      usrsock_sem_timedwait(&state.recvsem, false, UINT_MAX);
 
       ret = state.result;
       if (ret < 0)
@@ -188,7 +188,7 @@ close_out:
   conn->usockid = USRSOCK_USOCKID_INVALID;
 
 errout:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_conn.c

@@ -53,6 +53,14 @@
 #  define CONFIG_NET_USRSOCK_MAX_CONNS 0
 #endif
 
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/* Global protection lock for usrsock socket */
+
+rmutex_t g_usrsock_lock = NXRMUTEX_INITIALIZER;
+
 /****************************************************************************
  * Private Data
  ****************************************************************************/
@@ -95,6 +103,7 @@ FAR struct usrsock_conn_s *usrsock_alloc(void)
       /* Make sure that the connection is marked as uninitialized */
 
       nxsem_init(&conn->resp.sem, 0, 1);
+      nxrmutex_init(&conn->sconn.s_lock);
       conn->usockid = USRSOCK_USOCKID_INVALID;
       conn->state = USRSOCK_CONN_STATE_UNINITIALIZED;
 
@@ -131,6 +140,7 @@ void usrsock_free(FAR struct usrsock_conn_s *conn)
   /* Reset structure */
 
   nxsem_destroy(&conn->resp.sem);
+  nxrmutex_destroy(&conn->sconn.s_lock);
 
   /* Free the connection. */
 
@@ -214,7 +224,7 @@ int usrsock_setup_request_callback(FAR struct usrsock_conn_s *conn,
 
       if ((flags & USRSOCK_EVENT_REQ_COMPLETE) != 0)
         {
-          net_sem_wait_uninterruptible(&conn->resp.sem);
+          usrsock_sem_timedwait(&conn->resp.sem, false, UINT_MAX);
           pstate->unlock = true;
         }
 

net/usrsock/usrsock_connect.c

@@ -156,7 +156,7 @@ int usrsock_connect(FAR struct socket *psock,
 
   int ret;
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -223,7 +223,8 @@ int usrsock_connect(FAR struct socket *psock,
     {
       /* Wait for completion of request (or signal). */
 
-      ret = net_sem_wait(&state.recvsem);
+      ret = usrsock_sem_timedwait(&state.recvsem, true, UINT_MAX);
+
       if (ret < 0)
         {
           /* Wait interrupted, exit early. */
@@ -243,7 +244,7 @@ int usrsock_connect(FAR struct socket *psock,
 errout_teardown:
   usrsock_teardown_request_callback(&state);
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_devif.c

@@ -133,7 +133,7 @@ static ssize_t usrsock_iovec_do(FAR void *srcdst, size_t srcdstlen,
 
   while ((srclen > 0 || iovcnt > 0) && srcdstlen > 0)
     {
-      size_t clen = srclen;
+      size_t len = srclen;
 
       if (srclen == 0)
         {
@@ -147,25 +147,25 @@ static ssize_t usrsock_iovec_do(FAR void *srcdst, size_t srcdstlen,
           continue;
         }
 
-      if (clen > srcdstlen)
+      if (len > srcdstlen)
         {
-          clen = srcdstlen;
+          len = srcdstlen;
         }
 
       if (from_iov)
         {
-          memmove(ioout, iovbuf, clen);
+          memmove(ioout, iovbuf, len);
         }
       else
         {
-          memmove(iovbuf, ioout, clen);
+          memmove(iovbuf, ioout, len);
         }
 
-      ioout += clen;
-      srcdstlen -= clen;
-      iovbuf += clen;
-      srclen -= clen;
-      total += clen;
+      ioout += len;
+      srcdstlen -= len;
+      iovbuf += len;
+      srclen -= len;
+      total += len;
 
       if (srclen == 0)
         {
@@ -467,7 +467,7 @@ static ssize_t usrsock_handle_req_response(FAR const void *buffer,
       return -EINVAL;
     }
 
-  net_lock();
+  usrsock_lock();
 
   /* Get corresponding usrsock connection for this transfer */
 
@@ -503,7 +503,7 @@ static ssize_t usrsock_handle_req_response(FAR const void *buffer,
   ret = handle_response(conn, buffer, len);
 
 unlock_out:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 
@@ -650,7 +650,7 @@ int usrsock_do_request(FAR struct usrsock_conn_s *conn,
 
   /* Set outstanding request for daemon to handle. */
 
-  net_mutex_lock(&req->lock);
+  usrsock_mutex_timedlock(&req->lock, UINT_MAX);
   if (++req->newxid == 0)
     {
       ++req->newxid;
@@ -670,9 +670,9 @@ int usrsock_do_request(FAR struct usrsock_conn_s *conn,
     {
       /* Wait ack for request. */
 
-      ++req->nbusy; /* net_lock held. */
-      net_sem_wait_uninterruptible(&req->acksem);
-      --req->nbusy; /* net_lock held. */
+      ++req->nbusy; /* usrsock_lock held. */
+      usrsock_sem_timedwait(&req->acksem, false, UINT_MAX);
+      --req->nbusy; /* usrsock_lock held. */
     }
   else
     {
@@ -695,7 +695,7 @@ void usrsock_abort(void)
   FAR struct usrsock_conn_s *conn = NULL;
   int ret;
 
-  net_lock();
+  usrsock_lock();
 
   /* Set active usrsock sockets to aborted state. */
 
@@ -713,12 +713,12 @@ void usrsock_abort(void)
        * requests.
        */
 
-      ret = net_mutex_timedlock(&req->lock, 10);
+      ret = usrsock_mutex_timedlock(&req->lock, 10);
       if (ret < 0)
         {
           if (ret != -ETIMEDOUT && ret != -EINTR)
             {
-              ninfo("net_sem_timedwait errno: %d\n", ret);
+              ninfo("usrsock_mutex_timedlock errno: %d\n", ret);
               DEBUGASSERT(false);
             }
         }
@@ -738,7 +738,7 @@ void usrsock_abort(void)
     }
   while (true);
 
-  net_unlock();
+  usrsock_unlock();
 }
 
 #endif /* CONFIG_NET && CONFIG_NET_USRSOCK */

net/usrsock/usrsock_event.c

@@ -65,7 +65,7 @@ int usrsock_event(FAR struct usrsock_conn_s *conn)
       return OK;
     }
 
-  net_lock();
+  usrsock_lock();
 
   /* Generic state updates. */
 
@@ -118,7 +118,7 @@ int usrsock_event(FAR struct usrsock_conn_s *conn)
   /* Send events to callbacks */
 
   devif_conn_event(NULL, events, conn->sconn.list);
-  net_unlock();
+  usrsock_unlock();
 
   return OK;
 }

net/usrsock/usrsock_getpeername.c

@@ -166,7 +166,7 @@ int usrsock_getpeername(FAR struct socket *psock,
   socklen_t outaddrlen = 0;
   int ret;
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -204,7 +204,7 @@ int usrsock_getpeername(FAR struct socket *psock,
     {
       /* Wait for completion of request. */
 
-      net_sem_wait_uninterruptible(&state.reqstate.recvsem);
+      usrsock_sem_timedwait(&state.reqstate.recvsem, false, UINT_MAX);
       ret = state.reqstate.result;
 
       DEBUGASSERT(state.valuelen <= *addrlen);
@@ -222,7 +222,7 @@ int usrsock_getpeername(FAR struct socket *psock,
   usrsock_teardown_data_request_callback(&state);
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
 
   *addrlen = outaddrlen;
   return ret;

net/usrsock/usrsock_getsockname.c

@@ -166,7 +166,7 @@ int usrsock_getsockname(FAR struct socket *psock,
   socklen_t outaddrlen = 0;
   int ret;
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -204,7 +204,7 @@ int usrsock_getsockname(FAR struct socket *psock,
     {
       /* Wait for completion of request. */
 
-      net_sem_wait_uninterruptible(&state.reqstate.recvsem);
+      usrsock_sem_timedwait(&state.reqstate.recvsem, false, UINT_MAX);
       ret = state.reqstate.result;
 
       DEBUGASSERT(state.valuelen <= *addrlen);
@@ -222,7 +222,7 @@ int usrsock_getsockname(FAR struct socket *psock,
   usrsock_teardown_data_request_callback(&state);
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
 
   *addrlen = outaddrlen;
   return ret;

net/usrsock/usrsock_getsockopt.c

@@ -189,7 +189,7 @@ int usrsock_getsockopt(FAR struct socket *psock, int level, int option,
       return -ENOPROTOOPT;
     }
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -227,7 +227,7 @@ int usrsock_getsockopt(FAR struct socket *psock, int level, int option,
     {
       /* Wait for completion of request. */
 
-      net_sem_wait_uninterruptible(&state.reqstate.recvsem);
+      usrsock_sem_timedwait(&state.reqstate.recvsem, false, UINT_MAX);
       ret = state.reqstate.result;
 
       DEBUGASSERT(state.valuelen <= *value_len);
@@ -251,7 +251,7 @@ int usrsock_getsockopt(FAR struct socket *psock, int level, int option,
     }
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_ioctl.c

@@ -191,7 +191,7 @@ int usrsock_ioctl(FAR struct socket *psock, int cmd, unsigned long arg_)
       return arglen;
     }
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -238,7 +238,7 @@ int usrsock_ioctl(FAR struct socket *psock, int cmd, unsigned long arg_)
     {
       /* Wait for completion of request. */
 
-      net_sem_wait_uninterruptible(&state.reqstate.recvsem);
+      usrsock_sem_timedwait(&state.reqstate.recvsem, false, UINT_MAX);
       ret = state.reqstate.result;
 
       DEBUGASSERT(state.valuelen <= arglen);
@@ -249,7 +249,7 @@ int usrsock_ioctl(FAR struct socket *psock, int cmd, unsigned long arg_)
   usrsock_teardown_data_request_callback(&state);
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_listen.c

@@ -150,7 +150,7 @@ int usrsock_listen(FAR struct socket *psock, int backlog)
 
   int ret;
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -210,7 +210,7 @@ int usrsock_listen(FAR struct socket *psock, int backlog)
 
   /* Wait for completion of request (or signal). */
 
-  ret = net_sem_wait(&state.recvsem);
+  ret = usrsock_sem_timedwait(&state.recvsem, true, UINT_MAX);
   if (ret < 0)
     {
       /* Wait interrupted, exit early. */
@@ -223,7 +223,7 @@ int usrsock_listen(FAR struct socket *psock, int backlog)
 errout_teardown:
   usrsock_teardown_request_callback(&state);
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_poll.c

@@ -142,7 +142,7 @@ static int usrsock_pollsetup(FAR struct socket *psock,
     }
 #endif
 
-  net_lock();
+  usrsock_lock();
 
   /* Find a container to hold the poll information */
 
@@ -243,7 +243,7 @@ static int usrsock_pollsetup(FAR struct socket *psock,
   poll_notify(&fds, 1, eventset);
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 
@@ -278,6 +278,8 @@ static int usrsock_pollteardown(FAR struct socket *psock,
     }
 #endif
 
+  usrsock_lock();
+
   /* Recover the socket descriptor poll state info from the poll structure */
 
   info = (FAR struct usrsock_poll_s *)fds->priv;
@@ -300,6 +302,8 @@ static int usrsock_pollteardown(FAR struct socket *psock,
       info->conn = NULL;
     }
 
+  usrsock_unlock();
+
   return OK;
 }
 

net/usrsock/usrsock_recvmsg.c

@@ -237,7 +237,7 @@ ssize_t usrsock_recvmsg(FAR struct socket *psock, FAR struct msghdr *msg,
       addrlen = *fromlen;
     }
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -330,8 +330,8 @@ ssize_t usrsock_recvmsg(FAR struct socket *psock, FAR struct msghdr *msg,
 
           /* Wait for receive-avail (or abort, or timeout, or signal). */
 
-          ret = net_sem_timedwait(&state.reqstate.recvsem,
-                              _SO_TIMEOUT(conn->sconn.s_rcvtimeo));
+          ret = usrsock_sem_timedwait(&state.reqstate.recvsem, true,
+                                      _SO_TIMEOUT(conn->sconn.s_rcvtimeo));
           usrsock_teardown_data_request_callback(&state);
           if (ret < 0)
             {
@@ -347,7 +347,7 @@ ssize_t usrsock_recvmsg(FAR struct socket *psock, FAR struct msghdr *msg,
                 }
               else
                 {
-                  nerr("net_sem_timedwait errno: %zd\n", ret);
+                  nerr("usrsock_sem_timedwait errno: %zd\n", ret);
                   DEBUGPANIC();
                 }
 
@@ -403,7 +403,7 @@ ssize_t usrsock_recvmsg(FAR struct socket *psock, FAR struct msghdr *msg,
         {
           /* Wait for completion of request. */
 
-          net_sem_wait_uninterruptible(&state.reqstate.recvsem);
+          usrsock_sem_timedwait(&state.reqstate.recvsem, false, UINT_MAX);
           ret = state.reqstate.result;
 
           DEBUGASSERT(ret <= (ssize_t)len);
@@ -435,7 +435,7 @@ ssize_t usrsock_recvmsg(FAR struct socket *psock, FAR struct msghdr *msg,
   while (ret == -EAGAIN);
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
 
   if (fromlen)
     {

net/usrsock/usrsock_sendmsg.c

@@ -211,7 +211,7 @@ ssize_t usrsock_sendmsg(FAR struct socket *psock,
 
   ssize_t ret;
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -307,8 +307,8 @@ ssize_t usrsock_sendmsg(FAR struct socket *psock,
 
           /* Wait for send-ready (or abort, or timeout, or signal). */
 
-          ret = net_sem_timedwait(&state.recvsem,
-                              _SO_TIMEOUT(conn->sconn.s_sndtimeo));
+          ret = usrsock_sem_timedwait(&state.recvsem, true,
+                                      _SO_TIMEOUT(conn->sconn.s_sndtimeo));
           usrsock_teardown_request_callback(&state);
           if (ret < 0)
             {
@@ -324,7 +324,7 @@ ssize_t usrsock_sendmsg(FAR struct socket *psock,
                 }
               else
                 {
-                  nerr("net_sem_timedwait errno: %zd\n", ret);
+                  nerr("usrsock_sem_timedwait errno: %zd\n", ret);
                   DEBUGPANIC();
                 }
 
@@ -372,7 +372,7 @@ ssize_t usrsock_sendmsg(FAR struct socket *psock,
         {
           /* Wait for completion of request. */
 
-          net_sem_wait_uninterruptible(&state.recvsem);
+          usrsock_sem_timedwait(&state.recvsem, false, UINT_MAX);
           ret = state.result;
         }
 
@@ -381,7 +381,7 @@ ssize_t usrsock_sendmsg(FAR struct socket *psock,
   while (ret == -EAGAIN);
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_setsockopt.c

@@ -177,7 +177,7 @@ int usrsock_setsockopt(FAR struct socket *psock, int level, int option,
       return -ENOPROTOOPT;
     }
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -210,7 +210,7 @@ int usrsock_setsockopt(FAR struct socket *psock, int level, int option,
     {
       /* Wait for completion of request. */
 
-      net_sem_wait_uninterruptible(&state.recvsem);
+      usrsock_sem_timedwait(&state.recvsem, false, UINT_MAX);
       ret = state.result;
     }
 
@@ -224,7 +224,7 @@ int usrsock_setsockopt(FAR struct socket *psock, int level, int option,
     }
 
 errout_unlock:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_shutdown.c

@@ -145,7 +145,7 @@ int usrsock_shutdown(FAR struct socket *psock, int how)
 
   int ret;
 
-  net_lock();
+  usrsock_lock();
 
   if (conn->state == USRSOCK_CONN_STATE_UNINITIALIZED ||
       conn->state == USRSOCK_CONN_STATE_ABORTED)
@@ -176,14 +176,14 @@ int usrsock_shutdown(FAR struct socket *psock, int how)
     {
       /* Wait for completion of request. */
 
-      net_sem_wait_uninterruptible(&state.recvsem);
+      usrsock_sem_timedwait(&state.recvsem, false, UINT_MAX);
       ret = state.result;
     }
 
   usrsock_teardown_request_callback(&state);
 
 errout:
-  net_unlock();
+  usrsock_unlock();
   return ret;
 }
 

net/usrsock/usrsock_socket.c

@@ -205,7 +205,7 @@ int usrsock_socket(int domain, int type, int protocol,
       return -ENOMEM;
     }
 
-  net_lock();
+  usrsock_lock();
 
   /* Set up event callback for usrsock. */
 
@@ -227,7 +227,7 @@ int usrsock_socket(int domain, int type, int protocol,
 
   /* Wait for completion of request. */
 
-  net_sem_wait_uninterruptible(&state.recvsem);
+  usrsock_sem_timedwait(&state.recvsem, false, UINT_MAX);
 
   if (state.result < 0)
     {
@@ -240,14 +240,14 @@ int usrsock_socket(int domain, int type, int protocol,
 
   usrsock_teardown_request_callback(&state);
 
-  net_unlock();
+  usrsock_unlock();
   return OK;
 
 errout_teardown_callback:
   usrsock_teardown_request_callback(&state);
 errout_free_conn:
   usrsock_free(conn);
-  net_unlock();
+  usrsock_unlock();
   return err;
 }
 

net/utils/net_lock.c

@@ -250,63 +250,6 @@ int net_sem_timedwait(FAR sem_t *sem, unsigned int timeout)
   return net_sem_timedwait2(sem, true, timeout, &g_netlock, NULL);
 }
 
-/****************************************************************************
- * Name: net_mutex_timedlock
- *
- * Description:
- *   Atomically wait for mutex (or a timeout) while temporarily releasing
- *   the lock on the network.
- *
- *   Caution should be utilized.  Because the network lock is relinquished
- *   during the wait, there could be changes in the network state that occur
- *   before the lock is recovered.  Your design should account for this
- *   possibility.
- *
- * Input Parameters:
- *   mutex   - A reference to the mutex to be taken.
- *   timeout - The relative time to wait until a timeout is declared.
- *
- * Returned Value:
- *   Zero (OK) is returned on success; a negated errno value is returned on
- *   any failure.
- *
- ****************************************************************************/
-
-int net_mutex_timedlock(FAR mutex_t *mutex, unsigned int timeout)
-{
-  unsigned int count;
-  int          blresult;
-  int          ret;
-
-  /* Release the network lock, remembering my count.  net_breaklock will
-   * return a negated value if the caller does not hold the network lock.
-   */
-
-  blresult = net_breaklock(&count);
-
-  /* Now take the mutex, waiting if so requested. */
-
-  if (timeout != UINT_MAX)
-    {
-      ret = nxmutex_timedlock(mutex, timeout);
-    }
-  else
-    {
-      /* Wait as long as necessary to get the lock */
-
-      ret = nxmutex_lock(mutex);
-    }
-
-  /* Recover the network lock at the proper count (if we held it before) */
-
-  if (blresult >= 0)
-    {
-      net_restorelock(count);
-    }
-
-  return ret;
-}
-
 /****************************************************************************
  * Name: net_sem_wait
  *
@@ -332,31 +275,6 @@ int net_sem_wait(FAR sem_t *sem)
   return net_sem_timedwait(sem, UINT_MAX);
 }
 
-/****************************************************************************
- * Name: net_mutex_lock
- *
- * Description:
- *   Atomically wait for mutex while temporarily releasing the network lock.
- *
- *   Caution should be utilized.  Because the network lock is relinquished
- *   during the wait, there could be changes in the network state that occur
- *   before the lock is recovered.  Your design should account for this
- *   possibility.
- *
- * Input Parameters:
- *   mutex - A reference to the mutex to be taken.
- *
- * Returned Value:
- *   Zero (OK) is returned on success; a negated errno value is returned on
- *   any failure.
- *
- ****************************************************************************/
-
-int net_mutex_lock(FAR mutex_t *mutex)
-{
-  return net_mutex_timedlock(mutex, UINT_MAX);
-}
-
 /****************************************************************************
  * Name: net_sem_timedwait_uninterruptible
  *