leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tipc: use negative error return values in functions

Browse Source 
In some places, TIPC functions returns positive integers as return
codes. This goes against standard Linux coding practice, and may
even cause problems in some cases.

We now change the return values of the functions filter_rcv()
and filter_connect() to become signed integers, and return
negative error codes when needed. The codes we use in these
particular cases are still TIPC specific, since they are both
part of the TIPC API and have no correspondence in errno.h

Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Reviewed-by: Erik Hugne <erik.hugne@ericsson.com>
Reviewed-by: Ying Xue <ying.xue@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Jon Paul Maloy 2014-06-25 20:41:31 -05:00 committed by David S. Miller
parent 3d09fc4244
commit e4de5fab80
1 changed files with 23 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
net/tipc/socket.c
View File

@ -1269,17 +1269,16 @@ static void tipc_data_ready(struct sock *sk)
* @tsk: TIPC socket
* @msg: message
*
* Returns TIPC error status code and socket error status code
* once it encounters some errors
* Returns 0 (TIPC_OK) if everyting ok, -TIPC_ERR_NO_PORT otherwise
*/
static u32 filter_connect(struct tipc_sock *tsk, struct sk_buff **buf)
static int filter_connect(struct tipc_sock *tsk, struct sk_buff **buf)
{
struct sock *sk = &tsk->sk;
struct tipc_port *port = &tsk->port;
struct socket *sock = sk->sk_socket;
struct tipc_msg *msg = buf_msg(*buf);
u32 retval = TIPC_ERR_NO_PORT;
int retval = -TIPC_ERR_NO_PORT;
int res;
if (msg_mcast(msg))
@ -1382,32 +1381,33 @@ static unsigned int rcvbuf_limit(struct sock *sk, struct sk_buff *buf)
*
* Called with socket lock already taken; port lock may also be taken.
*
* Returns TIPC error status code (TIPC_OK if message is not to be rejected)
* Returns 0 (TIPC_OK) if message was consumed, -TIPC error code if message
* to be rejected.
*/
static u32 filter_rcv(struct sock *sk, struct sk_buff *buf)
static int filter_rcv(struct sock *sk, struct sk_buff *buf)
{
struct socket *sock = sk->sk_socket;
struct tipc_sock *tsk = tipc_sk(sk);
struct tipc_msg *msg = buf_msg(buf);
unsigned int limit = rcvbuf_limit(sk, buf);
u32 res = TIPC_OK;
int rc = TIPC_OK;
/* Reject message if it is wrong sort of message for socket */
if (msg_type(msg) > TIPC_DIRECT_MSG)
return TIPC_ERR_NO_PORT;
return -TIPC_ERR_NO_PORT;
if (sock->state == SS_READY) {
if (msg_connected(msg))
return TIPC_ERR_NO_PORT;
return -TIPC_ERR_NO_PORT;
} else {
res = filter_connect(tsk, &buf);
if (res != TIPC_OK || buf == NULL)
return res;
rc = filter_connect(tsk, &buf);
if (rc != TIPC_OK || buf == NULL)
return rc;
}
/* Reject message if there isn't room to queue it */
if (sk_rmem_alloc_get(sk) + buf->truesize >= limit)
return TIPC_ERR_OVERLOAD;
return -TIPC_ERR_OVERLOAD;
/* Enqueue message */
TIPC_SKB_CB(buf)->handle = NULL;
@ -1429,13 +1429,13 @@ static u32 filter_rcv(struct sock *sk, struct sk_buff *buf)
*/
static int tipc_backlog_rcv(struct sock *sk, struct sk_buff *buf)
{
u32 res;
int rc;
struct tipc_sock *tsk = tipc_sk(sk);
uint truesize = buf->truesize;
res = filter_rcv(sk, buf);
if (unlikely(res))
tipc_reject_msg(buf, res);
rc = filter_rcv(sk, buf);
if (unlikely(rc))
tipc_reject_msg(buf, -rc);
if (atomic_read(&tsk->dupl_rcvcnt) < TIPC_CONN_OVERLOAD_LIMIT)
atomic_add(truesize, &tsk->dupl_rcvcnt);
@ -1455,7 +1455,7 @@ int tipc_sk_rcv(struct sk_buff *buf)
struct tipc_port *port;
struct sock *sk;
u32 dport = msg_destport(buf_msg(buf));
int err = TIPC_OK;
int rc = TIPC_OK;
uint limit;
/* Forward unresolved named message */
@ -1467,7 +1467,7 @@ int tipc_sk_rcv(struct sk_buff *buf)
/* Validate destination */
port = tipc_port_lock(dport);
if (unlikely(!port)) {
err = TIPC_ERR_NO_PORT;
rc = -TIPC_ERR_NO_PORT;
goto exit;
}
@ -1478,22 +1478,22 @@ int tipc_sk_rcv(struct sk_buff *buf)
bh_lock_sock(sk);
if (!sock_owned_by_user(sk)) {
err = filter_rcv(sk, buf);
rc = filter_rcv(sk, buf);
} else {
if (sk->sk_backlog.len == 0)
atomic_set(&tsk->dupl_rcvcnt, 0);
limit = rcvbuf_limit(sk, buf) + atomic_read(&tsk->dupl_rcvcnt);
if (sk_add_backlog(sk, buf, limit))
err = TIPC_ERR_OVERLOAD;
rc = -TIPC_ERR_OVERLOAD;
}
bh_unlock_sock(sk);
tipc_port_unlock(port);
if (likely(!err))
if (likely(!rc))
return 0;
exit:
tipc_reject_msg(buf, err);
tipc_reject_msg(buf, -rc);
return -EHOSTUNREACH;
}