This is an automated email from the ASF dual-hosted git repository. acassis pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/nuttx.git
commit f27a9bbc2776bed0cb12990cf307702628280fc8 Author: zhanghongyu <[email protected]> AuthorDate: Mon Nov 17 10:05:31 2025 +0800 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 <[email protected]> --- drivers/usrsock/usrsock_dev.c | 2 +- drivers/usrsock/usrsock_rpmsg.c | 6 +- include/nuttx/net/net.h | 46 --------------- include/nuttx/net/usrsock.h | 118 ++++++++++++++++++++++++++++++++++++++ net/usrsock/usrsock_accept.c | 12 ++-- net/usrsock/usrsock_bind.c | 6 +- net/usrsock/usrsock_close.c | 6 +- net/usrsock/usrsock_conn.c | 12 +++- net/usrsock/usrsock_connect.c | 7 ++- net/usrsock/usrsock_devif.c | 40 ++++++------- net/usrsock/usrsock_event.c | 4 +- net/usrsock/usrsock_getpeername.c | 6 +- net/usrsock/usrsock_getsockname.c | 6 +- net/usrsock/usrsock_getsockopt.c | 6 +- net/usrsock/usrsock_ioctl.c | 6 +- net/usrsock/usrsock_listen.c | 6 +- net/usrsock/usrsock_poll.c | 8 ++- net/usrsock/usrsock_recvmsg.c | 12 ++-- net/usrsock/usrsock_sendmsg.c | 12 ++-- net/usrsock/usrsock_setsockopt.c | 6 +- net/usrsock/usrsock_shutdown.c | 6 +- net/usrsock/usrsock_socket.c | 8 +-- net/utils/net_lock.c | 82 -------------------------- 23 files changed, 214 insertions(+), 209 deletions(-) diff --git a/drivers/usrsock/usrsock_dev.c b/drivers/usrsock/usrsock_dev.c index 45f38731204..996be422eca 100644 --- a/drivers/usrsock/usrsock_dev.c +++ b/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)) { diff --git a/drivers/usrsock/usrsock_rpmsg.c b/drivers/usrsock/usrsock_rpmsg.c index 2c9c5ae3178..eb3b0323148 100644 --- a/drivers/usrsock/usrsock_rpmsg.c +++ b/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); } diff --git a/include/nuttx/net/net.h b/include/nuttx/net/net.h index 634e1c6a237..a77546dc2d7 100644 --- a/include/nuttx/net/net.h +++ b/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 * diff --git a/include/nuttx/net/usrsock.h b/include/nuttx/net/usrsock.h index 92de83d51be..558ab99b037 100644 --- a/include/nuttx/net/usrsock.h +++ b/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 */ diff --git a/net/usrsock/usrsock_accept.c b/net/usrsock/usrsock_accept.c index 5d4bc98375c..07e2f60adf9 100644 --- a/net/usrsock/usrsock_accept.c +++ b/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) { diff --git a/net/usrsock/usrsock_bind.c b/net/usrsock/usrsock_bind.c index 4ef2faea2f9..c0a74aafd7d 100644 --- a/net/usrsock/usrsock_bind.c +++ b/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; } diff --git a/net/usrsock/usrsock_close.c b/net/usrsock/usrsock_close.c index 21c4a0fe108..c9a0cb7fe26 100644 --- a/net/usrsock/usrsock_close.c +++ b/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; } diff --git a/net/usrsock/usrsock_conn.c b/net/usrsock/usrsock_conn.c index ff48e59ede6..52f9050d922 100644 --- a/net/usrsock/usrsock_conn.c +++ b/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; } diff --git a/net/usrsock/usrsock_connect.c b/net/usrsock/usrsock_connect.c index 3e5d98a5458..951b213e8b6 100644 --- a/net/usrsock/usrsock_connect.c +++ b/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; } diff --git a/net/usrsock/usrsock_devif.c b/net/usrsock/usrsock_devif.c index 0f0e55430bd..bf114e4902a 100644 --- a/net/usrsock/usrsock_devif.c +++ b/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 */ diff --git a/net/usrsock/usrsock_event.c b/net/usrsock/usrsock_event.c index 71fece8e724..dbf2fb8b573 100644 --- a/net/usrsock/usrsock_event.c +++ b/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; } diff --git a/net/usrsock/usrsock_getpeername.c b/net/usrsock/usrsock_getpeername.c index 2a541e5ab82..4adb768df6a 100644 --- a/net/usrsock/usrsock_getpeername.c +++ b/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; diff --git a/net/usrsock/usrsock_getsockname.c b/net/usrsock/usrsock_getsockname.c index bea2890ab5b..679fa385b90 100644 --- a/net/usrsock/usrsock_getsockname.c +++ b/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; diff --git a/net/usrsock/usrsock_getsockopt.c b/net/usrsock/usrsock_getsockopt.c index 4826bb59260..e01b2ad200e 100644 --- a/net/usrsock/usrsock_getsockopt.c +++ b/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; } diff --git a/net/usrsock/usrsock_ioctl.c b/net/usrsock/usrsock_ioctl.c index 15592dae072..06cd1aa2283 100644 --- a/net/usrsock/usrsock_ioctl.c +++ b/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; } diff --git a/net/usrsock/usrsock_listen.c b/net/usrsock/usrsock_listen.c index d5fd825191f..fca51913bd9 100644 --- a/net/usrsock/usrsock_listen.c +++ b/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; } diff --git a/net/usrsock/usrsock_poll.c b/net/usrsock/usrsock_poll.c index b5841184708..159b8a97a8f 100644 --- a/net/usrsock/usrsock_poll.c +++ b/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; } diff --git a/net/usrsock/usrsock_recvmsg.c b/net/usrsock/usrsock_recvmsg.c index c599526c35b..67d34569170 100644 --- a/net/usrsock/usrsock_recvmsg.c +++ b/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) { diff --git a/net/usrsock/usrsock_sendmsg.c b/net/usrsock/usrsock_sendmsg.c index 04879119332..8e86366ef63 100644 --- a/net/usrsock/usrsock_sendmsg.c +++ b/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; } diff --git a/net/usrsock/usrsock_setsockopt.c b/net/usrsock/usrsock_setsockopt.c index 1a7fca43334..c065625769c 100644 --- a/net/usrsock/usrsock_setsockopt.c +++ b/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; } diff --git a/net/usrsock/usrsock_shutdown.c b/net/usrsock/usrsock_shutdown.c index 6b22331edf6..7d50948cf90 100644 --- a/net/usrsock/usrsock_shutdown.c +++ b/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; } diff --git a/net/usrsock/usrsock_socket.c b/net/usrsock/usrsock_socket.c index 980117ebbb7..167b007cfbf 100644 --- a/net/usrsock/usrsock_socket.c +++ b/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; } diff --git a/net/utils/net_lock.c b/net/utils/net_lock.c index 3393762c4e6..60fe754ee88 100644 --- a/net/utils/net_lock.c +++ b/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 *
