net: replace net_sem*wait with conn_dev_sem*wait to simplify code logic

optimize the current code format according to the previous net_xxx_wait
implementation to reduce multiple calls of similar code

Signed-off-by: zhanghongyu <[email protected]>

Author: zhhyu7

include/nuttx/net/net.h

@@ -452,24 +452,6 @@ int net_sem_wait(FAR sem_t *sem);
 
 int net_sem_timedwait_uninterruptible(FAR sem_t *sem, unsigned int timeout);
 
-/****************************************************************************
- * Name: net_sem_wait_uninterruptible
- *
- * Description:
- *   This function is wrapped version of net_sem_wait(), which is
- *   uninterruptible and convenient for use.
- *
- * Input Parameters:
- *   sem - A reference to the semaphore to be taken.
- *
- * Returned Value:
- *   Zero (OK) is returned on success; a negated errno value is returned on
- *   any failure.
- *
- ****************************************************************************/
-
-int net_sem_wait_uninterruptible(FAR sem_t *sem);
-
 /****************************************************************************
  * Name: net_sem_timedwait2
  *

net/arp/arp_notify.c

@@ -156,7 +156,7 @@ int arp_wait(FAR struct arp_notify_s *notify, unsigned int timeout)
 
   /* And wait for the ARP response (or a timeout). */
 
-  net_sem_timedwait_uninterruptible(&notify->nt_sem, timeout);
+  nxsem_tickwait_uninterruptible(&notify->nt_sem, MSEC2TICK(timeout));
 
   /* Then get the real result of the transfer */
 

net/arp/arp_send.c

@@ -374,15 +374,15 @@ int arp_send(in_addr_t ipaddr)
       netdev_txnotify_dev(dev, ARP_POLL);
 
       /* Wait for the send to complete or an error to occur.
-       * net_sem_wait will also terminate if a signal is received.
+       * nxsem_tickwait will also terminate if a signal is received.
        */
 
       netdev_unlock(dev);
 
       do
         {
-          ret = net_sem_timedwait_uninterruptible(&state.snd_sem,
-                                              CONFIG_ARP_SEND_DELAYMSEC);
+          ret = nxsem_tickwait(&state.snd_sem,
+                               MSEC2TICK(CONFIG_ARP_SEND_DELAYMSEC));
           if (ret == -ETIMEDOUT)
             {
               arp_wait_cancel(&notify);

net/bluetooth/bluetooth_recvmsg.c

@@ -385,9 +385,10 @@ ssize_t bluetooth_recvmsg(FAR struct socket *psock, FAR struct msghdr *msg,
       state.ir_cb->event = bluetooth_recvfrom_eventhandler;
 
       /* Wait for either the receive to complete or for an error/timeout to
-       * occur. NOTES:  (1) net_sem_wait will also terminate if a signal
-       * is received, (2) the network is locked!  It will be un-locked while
-       * the task sleeps and automatically re-locked when the task restarts.
+       * occur. NOTES:  (1) conn_dev_sem_timedwait will also terminate if a
+       * signal is received, (2) the network is locked!  It will be un-locked
+       * while the task sleeps and automatically re-locked when the task
+       * restarts.
        */
 
       conn_dev_sem_timedwait(&state.ir_sem, true, UINT_MAX,

net/bluetooth/bluetooth_sendmsg.c

@@ -347,7 +347,8 @@ static ssize_t bluetooth_sendto(FAR struct socket *psock,
           netdev_txnotify_dev(&radio->r_dev, BLUETOOTH_POLL);
 
           /* Wait for the send to complete or an error to occur.
-           * net_sem_wait will also terminate if a signal is received.
+           * conn_dev_sem_timedwait will also terminate if a signal is
+           * received.
            */
 
           ret = conn_dev_sem_timedwait(&state.is_sem, true, UINT_MAX,
@@ -371,9 +372,9 @@ static ssize_t bluetooth_sendto(FAR struct socket *psock,
       return state.is_sent;
     }
 
-  /* If net_sem_wait failed, then we were probably reawakened by a signal.
-   * In this case, net_sem_wait will have returned negated errno
-   * appropriately.
+  /* If conn_dev_sem_timedwait failed, then we were probably reawakened by
+   * a signal. In this case, conn_dev_sem_timedwait will have returned
+   * negated errno appropriately.
    */
 
   if (ret < 0)

net/can/can_recvmsg.c

@@ -360,7 +360,8 @@ static uint32_t can_recvfrom_eventhandler(FAR struct net_driver_s *dev,
  *   Evaluate the result of the recv operations
  *
  * Input Parameters:
- *   result   The result of the net_sem_wait operation (may indicate EINTR)
+ *   result   The result of the conn_dev_sem_timedwait operation
+ *            (may indicate EINTR)
  *   pstate   A pointer to the state structure to be initialized
  *
  * Returned Value:
@@ -384,9 +385,9 @@ static ssize_t can_recvfrom_result(int result,
       return pstate->pr_result;
     }
 
-  /* If net_sem_wait failed, then we were probably reawakened by a signal.
-   * In this case, net_sem_wait will have returned negated errno
-   * appropriately.
+  /* If conn_dev_sem_timedwait failed, then we were probably reawakened by
+   * a signal. In this case, conn_dev_sem_timedwait will have returned
+   * negated errno appropriately.
    */
 
   if (result < 0)
@@ -518,14 +519,14 @@ ssize_t can_recvmsg(FAR struct socket *psock, FAR struct msghdr *msg,
       state.pr_cb->event = can_recvfrom_eventhandler;
 
       /* Wait for either the receive to complete or for an error/timeout to
-       * occur. NOTES:  (1) net_sem_wait will also terminate if a signal
-       * is received, (2) the network is locked!  It will be un-locked while
-       * the task sleeps and automatically re-locked when the task restarts.
+       * occur. NOTES:  (1) conn_dev_sem_timedwait will also terminate if a
+       * signal is received, (2) the network is locked!  It will be un-locked
+       * while the task sleeps and automatically re-locked when the task
+       * restarts.
        */
 
-      conn_dev_unlock(&conn->sconn, dev);
-      ret = net_sem_wait(&state.pr_sem);
-      conn_dev_lock(&conn->sconn, dev);
+      ret = conn_dev_sem_timedwait(&state.pr_sem, true, UINT_MAX,
+                                   &conn->sconn, dev);
 
       /* Make sure that no further events are processed */
 

net/can/can_sendmsg.c

@@ -264,21 +264,20 @@ ssize_t can_sendmsg(FAR struct socket *psock, FAR struct msghdr *msg,
       netdev_txnotify_dev(dev, CAN_POLL);
 
       /* Wait for the send to complete or an error to occur.
-       * net_sem_timedwait will also terminate if a signal is received.
+       * conn_dev_sem_timedwait will also terminate if a signal is received.
        */
 
-      conn_dev_unlock(&conn->sconn, dev);
       if (_SS_ISNONBLOCK(conn->sconn.s_flags) || (flags & MSG_DONTWAIT) != 0)
         {
-          ret = net_sem_timedwait(&state.snd_sem, 0);
+          ret = conn_dev_sem_timedwait(&state.snd_sem, true, 0,
+                                       &conn->sconn, dev);
         }
       else
         {
-          ret = net_sem_timedwait(&state.snd_sem, UINT_MAX);
+          ret = conn_dev_sem_timedwait(&state.snd_sem, true, UINT_MAX,
+                                       &conn->sconn, dev);
         }
 
-      conn_dev_lock(&conn->sconn, dev);
-
       /* Make sure that no further events are processed */
 
       can_callback_free(dev, conn, state.snd_cb);
@@ -296,9 +295,9 @@ ssize_t can_sendmsg(FAR struct socket *psock, FAR struct msghdr *msg,
       return state.snd_sent;
     }
 
-  /* If net_sem_wait failed, then we were probably reawakened by a signal.
-   * In this case, net_sem_wait will have returned negated errno
-   * appropriately.
+  /* If conn_dev_sem_timedwait failed, then we were probably reawakened by
+   * a signal. In this case, conn_dev_sem_timedwait will have returned
+   * negated errno appropriately.
    */
 
   if (ret < 0)

net/can/can_sendmsg_buffered.c

@@ -263,8 +263,9 @@ ssize_t can_sendmsg(FAR struct socket *psock, FAR struct msghdr *msg,
           goto errout_with_lock;
         }
 
-      ret = net_sem_timedwait_uninterruptible(&conn->sndsem,
-        _SO_TIMEOUT(conn->sconn.s_sndtimeo));
+      ret = conn_dev_sem_timedwait(&conn->sndsem, false,
+                                   _SO_TIMEOUT(conn->sconn.s_sndtimeo),
+                                   &conn->sconn, dev);
       if (ret < 0)
         {
           goto errout_with_lock;

net/devif/devif_callback.c

@@ -256,11 +256,12 @@ devif_callback_alloc(FAR struct net_driver_s *dev,
    */
 
   /* Note: dev->d_flags may be asynchronously changed by netdev_ifdown()
-   * (in net/netdev/netdev_ioctl.c). Nevertheless, net_lock() / net_unlock()
-   * are not required in netdev_ifdown() to prevent dev->d_flags from
-   * asynchronous change here. There is not an issue because net_lock() and
-   * net_unlock() present inside of devif_dev_event(). That should be enough
-   * to de-allocate connection callbacks reliably on NETDEV_DOWN event.
+   * (in net/netdev/netdev_ioctl.c). Nevertheless, netdev_lock() /
+   * netdev_unlock() are not required in netdev_ifdown() to prevent
+   * dev->d_flags from asynchronous change here. There is not an issue
+   * because netdev_lock() and netdev_unlock() present inside of
+   * devif_dev_event(). That should be enough to de-allocate connection
+   * callbacks reliably on NETDEV_DOWN event.
    */
 
   if (dev && !netdev_verify(dev))

net/icmp/icmp_recvmsg.c

@@ -374,14 +374,13 @@ ssize_t icmp_recvmsg(FAR struct socket *psock, FAR struct msghdr *msg,
           state.recv_cb->event = recvfrom_eventhandler;
 
           /* Wait for either the response to be received or for timeout to
-           * occur. net_sem_timedwait will also terminate if a signal is
+           * occur. conn_dev_sem_timedwait will also terminate if a signal is
            * received.
            */
 
-          conn_dev_unlock(&conn->sconn, dev);
-          ret = net_sem_timedwait(&state.recv_sem,
-                              _SO_TIMEOUT(conn->sconn.s_rcvtimeo));
-          conn_dev_lock(&conn->sconn, dev);
+          ret = conn_dev_sem_timedwait(&state.recv_sem, true,
+                                       _SO_TIMEOUT(conn->sconn.s_rcvtimeo),
+                                       &conn->sconn, dev);
           if (ret < 0)
             {
               state.recv_result = ret;