diff --git a/components/lwip/apps/multi-threads/sockets_mt.c b/components/lwip/apps/multi-threads/sockets_mt.c index a9eb0579..de00d0e1 100644 --- a/components/lwip/apps/multi-threads/sockets_mt.c +++ b/components/lwip/apps/multi-threads/sockets_mt.c @@ -111,14 +111,9 @@ #endif /* LWIP_POSIX_SOCKETS_IO_NAMES */ /********************************************************************/ - -#ifndef LWIP_SYNC_MT_SLEEP_MS #define LWIP_SYNC_MT_SLEEP_MS 10 -#endif -#ifndef SOCK_MT_DEBUG_LEVEL #define SOCK_MT_DEBUG_LEVEL 255 -#endif typedef struct socket_conn_sync { sys_sem_t *sem; @@ -127,52 +122,26 @@ typedef struct socket_conn_sync { typedef int (*lwip_io_mt_fn)(int, int ); -enum sock_mt_stat { - SOCK_MT_STATE_NONE = 0, - SOCK_MT_STATE_BIND, - SOCK_MT_STATE_LISTEN, - SOCK_MT_STATE_ACCEPT, - SOCK_MT_STATE_CONNECT, - SOCK_MT_STATE_SEND, -}; +/* Use about 2 bit */ +#define SOCK_MT_STATE_SOCK 0 +#define SOCK_MT_STATE_ACCEPT 1 +#define SOCK_MT_STATE_CONNECT 2 +#define SOCK_MT_STATE_SEND 3 +#define SOCK_MT_STATE_ILL 4 -enum sock_mt_shutdown { - SOCK_MT_SHUTDOWN_OK = 0, - SOCK_MT_SHUTDOWN_NONE -}; +#define SOCK_MT_LOCK_SEND (1 << 0) +#define SOCK_MT_LOCK_RECV (1 << 1) +#define SOCK_MT_LOCK_IOCTL (1 << 2) -enum sock_mt_module { - SOCK_MT_STATE, - SOCK_MT_RECV, - SOCK_MT_IOCTL, - SOCK_MT_SELECT, +#define SOCK_MT_SELECT_RECV (1 << 0) +#define SOCK_MT_SELECT_SEND (1 << 1) - SOCK_MT_SHUTDOWN, - - SOCK_MT_CLOSE, - - SOCK_MT_MODULE_MAX, -}; - -enum sock_mt_lock { - SOCK_MT_STATE_LOCK, - SOCK_MT_RECV_LOCK, - SOCK_MT_IOCTRL_LOCK, - - SOCK_MT_LOCK_MAX, -}; - -struct _sock_mt { - - enum sock_mt_shutdown shutdown; - - enum sock_mt_stat state; - - int sel; - - sys_mutex_t lock[SOCK_MT_LOCK_MAX]; -}; -typedef struct _sock_mt sock_mt_t; +typedef struct _sock_mt { + uint8_t opened : 1; + uint8_t state : 2; + uint8_t select : 2; + uint8_t lock : 3; +} sock_mt_t; #if (SOCK_MT_DEBUG_LEVEL < 16) #define SOCK_MT_DEBUG(level, ...) \ @@ -182,228 +151,140 @@ typedef struct _sock_mt sock_mt_t; #define SOCK_MT_DEBUG(level, ...) #endif -#if 0 -#define SOCK_MT_LOCK(s, l) \ -{ \ - SOCK_MT_DEBUG(1, "s %d l %d enter ", s, l); \ - sys_mutex_lock(&sockets_mt[s].lock[l]); \ - SOCK_MT_DEBUG(1, "OK\n"); \ +#define SOCK_MT_ENTER_CHECK(s, l, st) \ +{ \ + if (_sock_lock(s, l) != ERR_OK) \ + return -1; \ + if (st != SOCK_MT_STATE_ILL) \ + _sock_set_state(s, st); \ } -#define SOCK_MT_LOCK_RET(s, l, r) \ -{ \ - SOCK_MT_LOCK(s, l); \ - r = ERR_OK; \ +#define SOCK_MT_EXIT_CHECK(s, l, st) \ +{ \ + if (_sock_unlock(s, l) != ERR_OK) \ + return -1; \ + _sock_set_state(s, SOCK_MT_STATE_SOCK); \ } -#else -#define SOCK_MT_LOCK(s, l) \ -{ \ - SOCK_MT_DEBUG(1, "s %d l %d enter ", s, l); \ - while (1) { \ - err_t err; \ - SYS_ARCH_DECL_PROTECT(lev); \ - \ - SYS_ARCH_PROTECT(lev); \ - if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) \ - err = ERR_CLSD; \ - else \ - err = ERR_OK; \ - if (err == ERR_OK) { \ - if (sockets_mt[s].lock[l]) \ - err = sys_mutex_trylock(&sockets_mt[s].lock[l]); \ - else \ - err = ERR_VAL; \ - } \ - SYS_ARCH_UNPROTECT(lev); \ - \ - if (err == ERR_OK) \ - break; \ - else if (err == ERR_VAL || err == ERR_CLSD) \ - return -1; \ - \ - vTaskDelay(1); \ - } \ - SOCK_MT_DEBUG(1, "OK\n"); \ -} - -#define SOCK_MT_LOCK_RET(s, l, r) \ -{ \ - SOCK_MT_DEBUG(1, "s %d l %d enter ", s, l); \ - while (1) { \ - SYS_ARCH_DECL_PROTECT(lev); \ - \ - SYS_ARCH_PROTECT(lev); \ - if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) \ - r = ERR_CLSD; \ - else \ - r = ERR_OK; \ - if (r == ERR_OK) { \ - if (sockets_mt[s].lock[l]) \ - r = sys_mutex_trylock(&sockets_mt[s].lock[l]); \ - else \ - r = ERR_VAL; \ - } \ - SYS_ARCH_UNPROTECT(lev); \ - \ - if (r == ERR_OK || r == ERR_VAL || r == ERR_CLSD) \ - break; \ - vTaskDelay(1); \ - } \ - SOCK_MT_DEBUG(1, "OK\n"); \ -} -#endif - -#define SOCK_MT_TRYLOCK(s, l, r) \ -{ \ - SOCK_MT_DEBUG(1, "s %d l %d try enter ", s, l); \ - r = sys_mutex_trylock(&sockets_mt[s].lock[l]); \ - SOCK_MT_DEBUG(1, "ret %d OK\n", r); \ -} - -#define SOCK_MT_UNLOCK(s, l) \ -{ \ - SOCK_MT_DEBUG(1, "s %d l %d exit ", s, l); \ - sys_mutex_unlock(&sockets_mt[s].lock[l]); \ - SOCK_MT_DEBUG(1, "OK\n"); \ -} - - -#define SOCK_MT_SET_STATE(s, stat) \ -{ \ - SYS_ARCH_DECL_PROTECT(lev); \ - SYS_ARCH_PROTECT(lev); \ - sockets_mt[s].state = stat; \ - SYS_ARCH_UNPROTECT(lev); \ -} - -#define SOCK_MT_GET_STATE(s) \ - sockets_mt[s].state - -#define SOCK_MT_SET_SHUTDOWN(s, d) \ -{ \ - SYS_ARCH_DECL_PROTECT(lev); \ - SYS_ARCH_PROTECT(lev); \ - sockets_mt[s].shutdown = d; \ - SYS_ARCH_UNPROTECT(lev); \ -} - -#define SOCK_MT_GET_SHUTDOWN(s) \ - sockets_mt[s].shutdown - -#define SOCK_MT_SET_WRITE_SEL(s) \ -{ \ - SYS_ARCH_DECL_PROTECT(lev); \ - SYS_ARCH_PROTECT(lev); \ - sockets_mt[s].sel |= 0x1; \ - SYS_ARCH_UNPROTECT(lev); \ -} - -#define SOCK_MT_RESET_WRITE_SEL(s) \ -{ \ - SYS_ARCH_DECL_PROTECT(lev); \ - SYS_ARCH_PROTECT(lev); \ - sockets_mt[s].sel &= ~0x1; \ - SYS_ARCH_UNPROTECT(lev); \ -} - -#define SOCK_MT_GET_WRITE_SEL(s) \ - (sockets_mt[s].sel & 0x01) - -#define SOCK_MT_SET_READ_SEL(s) \ -{ \ - SYS_ARCH_DECL_PROTECT(lev); \ - SYS_ARCH_PROTECT(lev); \ - sockets_mt[s].sel |= 0x2; \ - SYS_ARCH_UNPROTECT(lev); \ -} - -#define SOCK_MT_RESET_READ_SEL(s) \ -{ \ - SYS_ARCH_DECL_PROTECT(lev); \ - SYS_ARCH_PROTECT(lev); \ - sockets_mt[s].sel &= ~0x2; \ - SYS_ARCH_UNPROTECT(lev); \ -} - -#define SOCK_MT_GET_READ_SEL(s) \ - (sockets_mt[s].sel & 0x02) - -#define SOCK_MT_GET_SEL(s) \ - sockets_mt[s].sel - -#define LWIP_ENTER_MT(s, m, p) \ -{ \ - int r; \ - SOCK_MT_DEBUG(1, "enter s %d module %d args %d\n", s, m, p); \ - r = lwip_enter_mt_table[m](s, p); \ - SOCK_MT_DEBUG(1, "enter s %d ret %d\n", s, r); \ - if (r) \ - return -1; \ -} - -#define LWIP_EXIT_MT(s, m, p) \ -{ \ - int r; \ - SOCK_MT_DEBUG(1, "exit s %d module %d args %d\n", s, m, p); \ - r = lwip_exit_mt_table[m](s, p); \ - SOCK_MT_DEBUG(1, "exit s %d ret %d\n", s, r); \ - if (r) \ - return -1; \ -} - static sock_mt_t sockets_mt[NUM_SOCKETS]; -static int lwip_enter_mt_state(int s, int arg) +static inline int _sock_is_opened(int s) { - if (tryget_socket(s) == NULL || - SOCK_MT_GET_STATE(s) != SOCK_MT_STATE_NONE || - SOCK_MT_GET_WRITE_SEL(s)) - return -1; - - SOCK_MT_LOCK(s, SOCK_MT_STATE_LOCK); - SOCK_MT_SET_STATE(s, arg); - - return 0; + return sockets_mt[s].opened != 0; } -static int lwip_enter_mt_recv(int s, int arg) +static inline void _sock_set_open(int s, int opened) { - if (tryget_socket(s) == NULL || - SOCK_MT_GET_READ_SEL(s)) - return -1; - - SOCK_MT_LOCK(s, SOCK_MT_RECV_LOCK); - - return 0; + sockets_mt[s].opened = opened; } -static int lwip_enter_mt_shutdown(int s, int arg) +static inline void _sock_set_state(int s, int state) { - if (tryget_socket(s) == NULL - || SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) - return -1; - - SOCK_MT_SET_SHUTDOWN(s, SOCK_MT_SHUTDOWN_OK); - - return 0; + sockets_mt[s].state = state; } -static int lwip_enter_mt_close(int s, int arg) +static inline int _sock_get_state(int s) { + return sockets_mt[s].state; +} + +static inline int _sock_get_select(int s, int select) +{ + return sockets_mt[s].select & select; +} + +static void _sock_set_select(int s, int select) +{ + SYS_ARCH_DECL_PROTECT(lev); + + SYS_ARCH_PROTECT(lev); + sockets_mt[s].select |= select; + SYS_ARCH_UNPROTECT(lev); +} + +static void _sock_reset_select(int s, int select) +{ + SYS_ARCH_DECL_PROTECT(lev); + + SYS_ARCH_PROTECT(lev); + sockets_mt[s].select &= ~select; + SYS_ARCH_UNPROTECT(lev); +} + +static int _sock_try_lock(int s, int l) +{ + int ret = ERR_OK; + SYS_ARCH_DECL_PROTECT(lev); + + SYS_ARCH_PROTECT(lev); + if (!_sock_is_opened(s)) { + ret = ERR_CLSD; + goto exit; + } + + if (sockets_mt[s].lock & l) { + ret = ERR_INPROGRESS; + goto exit; + } + + sockets_mt[s].lock |= l; + +exit: + SYS_ARCH_UNPROTECT(lev); + + return ret; +} + +static int _sock_lock(int s, int l) +{ + int ret = ERR_OK; if (tryget_socket(s) == NULL) return -1; - SOCK_MT_SET_SHUTDOWN(s, SOCK_MT_SHUTDOWN_OK); + SOCK_MT_DEBUG(1, "s %d l %d enter ", s, l); - return 0; + while (1) { + ret = _sock_try_lock(s, l); + + if (ret != ERR_INPROGRESS) + break; + + vTaskDelay(1); + } + + SOCK_MT_DEBUG(1, "OK %d\n", ret); + + return ret; } +static int _sock_unlock(int s, int l) +{ + int ret = 0; + SYS_ARCH_DECL_PROTECT(lev); -static int lwip_enter_mt_select(int s, int arg) + SOCK_MT_DEBUG(1, "s %d l %d exit ", s, l); + + SYS_ARCH_PROTECT(lev); + + sockets_mt[s].lock &= ~l; + + if (!_sock_is_opened(s)) { + ret = ERR_CLSD; + goto exit; + } + +exit: + SYS_ARCH_UNPROTECT(lev); + + SOCK_MT_DEBUG(1, "OK %d\n", ret); + + return ret; +} + +static int lwip_enter_mt_select(int s, void *arg) { int i; - int *fdset = (int *)arg; + int *fdset = arg; fd_set *read_set = (fd_set *)fdset[0]; fd_set *write_set = (fd_set *)fdset[1]; @@ -418,8 +299,8 @@ static int lwip_enter_mt_select(int s, int arg) if (FD_ISSET(i, read_set)) { err_t err; - SOCK_MT_SET_READ_SEL(i); - SOCK_MT_LOCK_RET(i, SOCK_MT_RECV_LOCK, err); + _sock_set_select(i, SOCK_MT_SELECT_RECV); + err = _sock_lock(i, SOCK_MT_LOCK_RECV); if (err != ERR_OK) { goto failed2; } @@ -428,8 +309,8 @@ static int lwip_enter_mt_select(int s, int arg) if (FD_ISSET(i, write_set)) { err_t err; - SOCK_MT_SET_WRITE_SEL(i); - SOCK_MT_LOCK_RET(i, SOCK_MT_STATE_LOCK, err); + _sock_set_select(i, SOCK_MT_SELECT_SEND); + err = _sock_lock(i, SOCK_MT_LOCK_SEND); if (err != ERR_OK) { goto failed3; } @@ -439,131 +320,52 @@ static int lwip_enter_mt_select(int s, int arg) return 0; failed3: - SOCK_MT_UNLOCK(i, SOCK_MT_STATE_LOCK); - SOCK_MT_RESET_WRITE_SEL(i); + _sock_unlock(i, SOCK_MT_LOCK_SEND); + _sock_reset_select(i, SOCK_MT_SELECT_SEND); failed2: if (FD_ISSET(i, read_set)) { - SOCK_MT_UNLOCK(i, SOCK_MT_RECV_LOCK); - SOCK_MT_RESET_READ_SEL(i); + _sock_unlock(i, SOCK_MT_LOCK_RECV); + _sock_reset_select(i, SOCK_MT_SELECT_RECV); } failed1: for (i--; i >=0; i--) { if (FD_ISSET(i, read_set) ) { - SOCK_MT_UNLOCK(i, SOCK_MT_RECV_LOCK); - SOCK_MT_RESET_READ_SEL(i); + _sock_unlock(i, SOCK_MT_LOCK_RECV); + _sock_reset_select(i, SOCK_MT_SELECT_RECV); } if (FD_ISSET(i, write_set)) { - SOCK_MT_UNLOCK(i, SOCK_MT_STATE_LOCK); - SOCK_MT_RESET_WRITE_SEL(i); + _sock_unlock(i, SOCK_MT_LOCK_SEND); + _sock_reset_select(i, SOCK_MT_SELECT_SEND); } } return -1; } -static int lwip_enter_mt_ioctrl(int s, int arg) -{ - if (tryget_socket(s) == NULL) - return -1; - - SOCK_MT_LOCK(s, SOCK_MT_IOCTRL_LOCK); - - return 0; -} - -static int lwip_exit_mt_state(int s, int arg) -{ - SOCK_MT_SET_STATE(s, SOCK_MT_STATE_NONE); - SOCK_MT_UNLOCK(s, SOCK_MT_STATE_LOCK); - - if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) { - return -1; - } - - return 0; -} - -static int lwip_exit_mt_recv(int s, int arg) -{ - SOCK_MT_UNLOCK(s, SOCK_MT_RECV_LOCK); - - if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) { - return -1; - } - - return 0; -} - -static int lwip_exit_mt_shutdown(int s, int arg) -{ - //SOCK_MT_SET_SHUTDOWN(s, SOCK_MT_STATE_NONE); - return 0; -} - -static int lwip_exit_mt_close(int s, int arg) -{ - return 0; -} - -static int lwip_exit_mt_select(int s, int arg) +static int lwip_exit_mt_select(int s, void *arg) { int i; - int *fdset = (int *)arg; + int ret = 0; + int *fdset = arg; fd_set *read_set = (fd_set *)fdset[0]; fd_set *write_set = (fd_set *)fdset[1]; for (i = 0; i < s; i++) { if (FD_ISSET(i, read_set)) { - SOCK_MT_UNLOCK(i, SOCK_MT_RECV_LOCK); - SOCK_MT_RESET_READ_SEL(i); + ret |= _sock_unlock(i, SOCK_MT_LOCK_RECV); + _sock_reset_select(i, SOCK_MT_SELECT_RECV); } if (FD_ISSET(i, write_set)) { - SOCK_MT_UNLOCK(i, SOCK_MT_STATE_LOCK); - SOCK_MT_RESET_WRITE_SEL(i); + ret |= _sock_unlock(i, SOCK_MT_LOCK_SEND); + _sock_reset_select(i, SOCK_MT_LOCK_SEND); } } - for (i = 0; i < s; i++) { - if ((FD_ISSET(i, read_set) || FD_ISSET(i, write_set)) \ - && SOCK_MT_GET_SHUTDOWN(i) != SOCK_MT_SHUTDOWN_NONE) { - return -1; - } - } - - return 0; + return ret; } -static int lwip_exit_mt_ioctrl(int s, int arg) -{ - SOCK_MT_UNLOCK(s, SOCK_MT_IOCTRL_LOCK); - - if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) { - return -1; - } - - return 0; -} - -static const lwip_io_mt_fn lwip_enter_mt_table[] = { - lwip_enter_mt_state, - lwip_enter_mt_recv, - lwip_enter_mt_ioctrl, - lwip_enter_mt_select, - lwip_enter_mt_shutdown, - lwip_enter_mt_close -}; - -static const lwip_io_mt_fn lwip_exit_mt_table[] = { - lwip_exit_mt_state, - lwip_exit_mt_recv, - lwip_exit_mt_ioctrl, - lwip_exit_mt_select, - lwip_exit_mt_shutdown, - lwip_exit_mt_close -}; - static void lwip_do_sync_send(void *arg) { socket_conn_sync_t *sync = (socket_conn_sync_t *)arg; @@ -596,102 +398,85 @@ static void lwip_do_sync_rst_state(void *arg) sys_sem_signal(sync->sem); } -static void lwip_sync_state_mt(struct lwip_sock *sock, int state) +static void lwip_sync_state_mt(int s) { + struct lwip_sock *sock = tryget_socket(s); + int state = _sock_get_state(s); + SOCK_MT_DEBUG(1, "sync state %d\n", state); switch (state) { - case SOCK_MT_STATE_ACCEPT : - if (sys_mbox_valid(&sock->conn->acceptmbox)) - sys_mbox_trypost(&sock->conn->acceptmbox, NULL); - break; - case SOCK_MT_STATE_CONNECT: - case SOCK_MT_STATE_SEND : - { - socket_conn_sync_t sync; + case SOCK_MT_STATE_ACCEPT : + if (sys_mbox_valid(&sock->conn->acceptmbox)) + sys_mbox_trypost(&sock->conn->acceptmbox, NULL); + break; + case SOCK_MT_STATE_CONNECT: + case SOCK_MT_STATE_SEND : + { + socket_conn_sync_t sync; - sync.conn = sock->conn; - sync.sem = sys_thread_sem_get(); + sync.conn = sock->conn; + sync.sem = sys_thread_sem_get(); - tcpip_callback(lwip_do_sync_send, &sync); - sys_arch_sem_wait(sync.sem, 0); - break; - } - default : - break; + tcpip_callback(lwip_do_sync_send, &sync); + sys_arch_sem_wait(sync.sem, 0); + break; + } + default : + break; } } -static void lwip_sync_recv_mt(struct lwip_sock *sock) +static void lwip_sync_recv_mt(int s) { + struct lwip_sock *sock = tryget_socket(s); + SOCK_MT_DEBUG(1, "sync recv %d\n", sock->conn->socket); if (sys_mbox_valid(&sock->conn->recvmbox)) sys_mbox_trypost(&sock->conn->recvmbox, NULL); } -static void lwip_sync_select_mt(struct lwip_sock *sock) +static void lwip_sync_select_mt(int s) { + struct lwip_sock *sock = tryget_socket(s); + SOCK_MT_DEBUG(1, "sync select %d\n", sock->conn->socket); event_callback(sock->conn, NETCONN_EVT_ERROR, 0); } - -static inline bool is_need_sync(int s, int how, int module) -{ - int ret; - - switch (module) { - case SOCK_MT_STATE: - if (how == SHUT_RD) - return false; - break; - case SOCK_MT_RECV: - if (how == SHUT_WR) - return false; - break; - default: - break; - } - - /* - * we always lock the mutex in case of other thread entering, - * other thread will be blocked at "SOCK_MT_LOCK" and poll-check - */ - SOCK_MT_TRYLOCK(s, module, ret); - - return ret == ERR_OK ? false : true; -} - static void lwip_sync_mt(int s, int how) { - int module = 0; + int lock = SOCK_MT_LOCK_SEND; struct lwip_sock *sock; - while (module < SOCK_MT_SELECT) { + while (lock < SOCK_MT_LOCK_IOCTL) { + int need_wait = 0; extern void sys_arch_msleep(int ms); - if (is_need_sync(s, how, module) == false) { - module++; - continue; - } - - sock = get_socket(s); - if (!SOCK_MT_GET_SEL(s)) { - switch (module) { - case SOCK_MT_STATE: - lwip_sync_state_mt(sock, SOCK_MT_GET_STATE(s)); - break; - case SOCK_MT_RECV: - lwip_sync_recv_mt(sock); - break; - default : - break; + if (_sock_try_lock(s, lock) == ERR_INPROGRESS) { + if (!_sock_get_select(s, SOCK_MT_SELECT_RECV | SOCK_MT_SELECT_SEND)) { + switch (lock) { + case SOCK_MT_LOCK_SEND: + lwip_sync_state_mt(s); + need_wait = 1; + break; + case SOCK_MT_LOCK_RECV: + lwip_sync_recv_mt(s); + need_wait = 1; + break; + default : + break; + } + } else { + lwip_sync_select_mt(s); + need_wait = 1; } - } else { - lwip_sync_select_mt(sock); } - sys_arch_msleep(LWIP_SYNC_MT_SLEEP_MS); + if (need_wait) + sys_arch_msleep(LWIP_SYNC_MT_SLEEP_MS); + + lock++; } sock = tryget_socket(s); @@ -728,30 +513,13 @@ static void lwip_socket_set_so_link(int s, int linger) int lwip_socket(int domain, int type, int protocol) { int s; - int i; s = lwip_socket_esp(domain, type, protocol); if (s < 0) return -1; - for (i = 0; i < SOCK_MT_LOCK_MAX; i++) { - if (sys_mutex_new(&sockets_mt[s].lock[i]) != ERR_OK) - break; - } - if (i < SOCK_MT_LOCK_MAX) { - for (i-- ; i >= 0; i--) { - sys_mutex_free(&sockets_mt[s].lock[i]); - sockets_mt[s].lock[i] = NULL; - } - - lwip_close_esp(s); - s = -1; - } - - if (s >= 0) { - lwip_socket_set_so_link(s, 0); - SOCK_MT_SET_SHUTDOWN(s, SOCK_MT_SHUTDOWN_NONE); - } + lwip_socket_set_so_link(s, 0); + _sock_set_open(s, 1); return s; } @@ -760,12 +528,11 @@ int lwip_bind(int s, const struct sockaddr *name, socklen_t namelen) { int ret; - LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_BIND); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ILL); ret = lwip_bind_esp(s, name, namelen); - LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_BIND); - + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ILL); return ret; } @@ -774,11 +541,11 @@ int lwip_connect(int s, const struct sockaddr *name, socklen_t namelen) { int ret; - LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_CONNECT); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_CONNECT); ret = lwip_connect_esp(s, name, namelen); - LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_CONNECT); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_CONNECT); return ret; } @@ -787,51 +554,34 @@ int lwip_listen(int s, int backlog) { int ret; - LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_LISTEN); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ILL); lwip_socket_set_so_link(s, -1); ret = lwip_listen_esp(s, backlog); - LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_LISTEN); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ILL); return ret; } int lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen) { - int i; int ret; - LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_ACCEPT) + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ACCEPT) lwip_socket_set_so_link(s, -1); ret = lwip_accept_esp(s, addr, addrlen); - LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_ACCEPT); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_ACCEPT); if (ret < 0) return -1; - for (i = 0; i < SOCK_MT_LOCK_MAX; i++) { - if (sys_mutex_new(&sockets_mt[ret].lock[i]) != ERR_OK) - break; - } - if (i < SOCK_MT_LOCK_MAX) { - for (i-- ; i >= 0; i--) { - sys_mutex_free(&sockets_mt[ret].lock[i]); - sockets_mt[ret].lock[i] = NULL; - } - - lwip_close_esp(ret); - ret = -1; - } - - if (ret >= 0) { - lwip_socket_set_so_link(s, 0); - SOCK_MT_SET_SHUTDOWN(ret, SOCK_MT_SHUTDOWN_NONE); - } + lwip_socket_set_so_link(ret, 0); + _sock_set_open(ret, 1); return ret; } @@ -840,11 +590,11 @@ int lwip_getpeername(int s, struct sockaddr *name, socklen_t *namelen) { int ret; - LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); ret = lwip_getpeername_esp(s, name, namelen); - LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); return ret; } @@ -853,11 +603,11 @@ int lwip_getsockname(int s, struct sockaddr *name, socklen_t *namelen) { int ret; - LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); ret = lwip_getsockname_esp(s, name, namelen); - LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); return ret; } @@ -866,11 +616,11 @@ int lwip_setsockopt(int s, int level, int optname, const void *optval, socklen_t { int ret; - LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); ret = lwip_setsockopt_esp(s, level, optname, optval, optlen); - LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); return ret; } @@ -882,7 +632,7 @@ int lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optl if (optname == SO_ERROR) { int retval = 0; - if (SOCK_MT_GET_SHUTDOWN(s) != SOCK_MT_SHUTDOWN_NONE) + if (!_sock_is_opened(s)) retval = ENOTCONN; if (retval) { @@ -891,11 +641,11 @@ int lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optl } } - LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); ret = lwip_getsockopt_esp(s, level, optname, optval, optlen); - LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); return ret; } @@ -904,11 +654,11 @@ int lwip_ioctl(int s, long cmd, void *argp) { int ret; - LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0) + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL) ret = lwip_ioctl_esp(s, cmd, argp); - LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); return ret; } @@ -918,11 +668,11 @@ int lwip_sendto(int s, const void *data, size_t size, int flags, { int ret; - LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_SEND); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_SEND); ret = lwip_sendto_esp(s, data, size, flags, to, tolen); - LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_SEND); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_SEND); return ret; } @@ -931,11 +681,11 @@ int lwip_send(int s, const void *data, size_t size, int flags) { int ret; - LWIP_ENTER_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_SEND); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_SEND); ret = lwip_send_esp(s, data, size, flags); - LWIP_EXIT_MT(s, SOCK_MT_STATE, SOCK_MT_STATE_SEND); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_SEND, SOCK_MT_STATE_SEND); return ret; } @@ -945,11 +695,11 @@ int lwip_recvfrom(int s, void *mem, size_t len, int flags, { int ret; - LWIP_ENTER_MT(s, SOCK_MT_RECV, 0); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_RECV, SOCK_MT_STATE_ILL); ret = lwip_recvfrom_esp(s, mem, len, flags, from, fromlen); - LWIP_EXIT_MT(s, SOCK_MT_RECV, 0); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_RECV, SOCK_MT_STATE_ILL); return ret; } @@ -973,69 +723,30 @@ int lwip_fcntl(int s, int cmd, int val) { int ret; - LWIP_ENTER_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_ENTER_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); ret = lwip_fcntl_esp(s, cmd, val); - LWIP_EXIT_MT(s, SOCK_MT_IOCTL, 0); + SOCK_MT_EXIT_CHECK(s, SOCK_MT_LOCK_IOCTL, SOCK_MT_STATE_ILL); return ret; } -#ifdef SOCKETS_MT_DISABLE_SHUTDOWN int lwip_shutdown(int s, int how) { return 0; } -#else -int lwip_shutdown(int s, int how) -{ - int ret; - - LWIP_ENTER_MT(s, SOCK_MT_SHUTDOWN, 0); - - lwip_sync_mt(s, how); - - ret = lwip_shutdown_esp(s, how); - - LWIP_EXIT_MT(s, SOCK_MT_SHUTDOWN, 0); - - return ret; -} -#endif int lwip_close(int s) { int ret; - int i; - SYS_ARCH_DECL_PROTECT(lev); - sys_mutex_t lock_tmp[SOCK_MT_LOCK_MAX]; -#ifdef SOCKETS_MT_DISABLE_SHUTDOWN - LWIP_ENTER_MT(s, SOCK_MT_CLOSE, 0); + _sock_set_open(s, 0); lwip_sync_mt(s, SHUT_RDWR); -#else - lwip_shutdown(s, SHUT_RDWR); - - LWIP_ENTER_MT(s, SOCK_MT_CLOSE, 0); -#endif ret = lwip_close_esp(s); - LWIP_EXIT_MT(s, SOCK_MT_CLOSE, 0); - - SYS_ARCH_PROTECT(lev); - for (i = 0 ; i < SOCK_MT_LOCK_MAX; i++) { - lock_tmp[i] = sockets_mt[s].lock[i]; - sockets_mt[s].lock[i] = NULL; - } - SYS_ARCH_UNPROTECT(lev); - - for (i = 0 ; i < SOCK_MT_LOCK_MAX; i++) { - sys_mutex_free(&lock_tmp[i]); - } - return ret; } @@ -1055,11 +766,15 @@ int lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, if (writeset) MEMCPY(&write_set, writeset, sizeof(fd_set)); - LWIP_ENTER_MT(maxfdp1, SOCK_MT_SELECT, (int)pset); + ret = lwip_enter_mt_select(maxfdp1, pset); + if (ret) + return ret; ret = lwip_select_esp(maxfdp1, readset, writeset, exceptset, timeout); - LWIP_EXIT_MT(maxfdp1, SOCK_MT_SELECT, (int)pset); + ret = lwip_exit_mt_select(maxfdp1, pset); + if (ret) + return ret; return ret; }