FEX-Emu/linux
1
0
Fork 0
mirror of https://github.com/FEX-Emu/linux.git synced 2024-12-16 05:50:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

rxrpc: Use negative error codes in rxrpc_call struct

Browse Source 
Use negative error codes in struct rxrpc_call::error because that's what
the kernel normally deals with and to make the code consistent.  We only
turn them positive when transcribing into a cmsg for userspace recvmsg.

Signed-off-by: David Howells <dhowells@redhat.com>
This commit is contained in:
David Howells 2017-04-06 10:11:56 +01:00
parent faeeb317a5
commit 3a92789af0
10 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
fs/afs/rxrpc.c
View File

@ -419,7 +419,7 @@ error_do_abort:
call->state = AFS_CALL_COMPLETE; call->state = AFS_CALL_COMPLETE;
if (ret != -ECONNABORTED) { if (ret != -ECONNABORTED) {
rxrpc_kernel_abort_call(afs_socket, rxcall, RX_USER_ABORT, rxrpc_kernel_abort_call(afs_socket, rxcall, RX_USER_ABORT,
-ret, "KSD"); ret, "KSD");
} else { } else {
abort_code = 0; abort_code = 0;
offset = 0; offset = 0;
@ -478,12 +478,12 @@ static void afs_deliver_to_call(struct afs_call *call)
case -ENOTCONN: case -ENOTCONN:
abort_code = RX_CALL_DEAD; abort_code = RX_CALL_DEAD;
rxrpc_kernel_abort_call(afs_socket, call->rxcall, rxrpc_kernel_abort_call(afs_socket, call->rxcall,
abort_code, -ret, "KNC"); abort_code, ret, "KNC");
goto save_error; goto save_error;
case -ENOTSUPP: case -ENOTSUPP:
abort_code = RXGEN_OPCODE; abort_code = RXGEN_OPCODE;
rxrpc_kernel_abort_call(afs_socket, call->rxcall, rxrpc_kernel_abort_call(afs_socket, call->rxcall,
abort_code, -ret, "KIV"); abort_code, ret, "KIV");
goto save_error; goto save_error;
case -ENODATA: case -ENODATA:
case -EBADMSG: case -EBADMSG:
@ -493,7 +493,7 @@ static void afs_deliver_to_call(struct afs_call *call)
if (call->state != AFS_CALL_AWAIT_REPLY) if (call->state != AFS_CALL_AWAIT_REPLY)
abort_code = RXGEN_SS_UNMARSHAL; abort_code = RXGEN_SS_UNMARSHAL;
rxrpc_kernel_abort_call(afs_socket, call->rxcall, rxrpc_kernel_abort_call(afs_socket, call->rxcall,
abort_code, EBADMSG, "KUM"); abort_code, -EBADMSG, "KUM");
goto save_error; goto save_error;
} }
} }
@ -754,7 +754,7 @@ void afs_send_empty_reply(struct afs_call *call)
case -ENOMEM: case -ENOMEM:
_debug("oom"); _debug("oom");
rxrpc_kernel_abort_call(afs_socket, call->rxcall, rxrpc_kernel_abort_call(afs_socket, call->rxcall,
RX_USER_ABORT, ENOMEM, "KOO"); RX_USER_ABORT, -ENOMEM, "KOO");
default: default:
_leave(" [error]"); _leave(" [error]");
return; return;
@ -792,7 +792,7 @@ void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len)
if (n == -ENOMEM) { if (n == -ENOMEM) {
_debug("oom"); _debug("oom");
rxrpc_kernel_abort_call(afs_socket, call->rxcall, rxrpc_kernel_abort_call(afs_socket, call->rxcall,
RX_USER_ABORT, ENOMEM, "KOO"); RX_USER_ABORT, -ENOMEM, "KOO");
} }
_leave(" [error]"); _leave(" [error]");
} }

6
net/rxrpc/call_accept.c
View File

@ -413,11 +413,11 @@ found_service:
case RXRPC_CONN_REMOTELY_ABORTED: case RXRPC_CONN_REMOTELY_ABORTED:
rxrpc_set_call_completion(call, RXRPC_CALL_REMOTELY_ABORTED, rxrpc_set_call_completion(call, RXRPC_CALL_REMOTELY_ABORTED,
conn->remote_abort, ECONNABORTED); conn->remote_abort, -ECONNABORTED);
break; break;
case RXRPC_CONN_LOCALLY_ABORTED: case RXRPC_CONN_LOCALLY_ABORTED:
rxrpc_abort_call("CON", call, sp->hdr.seq, rxrpc_abort_call("CON", call, sp->hdr.seq,
conn->local_abort, ECONNABORTED); conn->local_abort, -ECONNABORTED);
break; break;
default: default:
BUG(); BUG();
@ -600,7 +600,7 @@ int rxrpc_reject_call(struct rxrpc_sock *rx)
write_lock_bh(&call->state_lock); write_lock_bh(&call->state_lock);
switch (call->state) { switch (call->state) {
case RXRPC_CALL_SERVER_ACCEPTING: case RXRPC_CALL_SERVER_ACCEPTING:
__rxrpc_abort_call("REJ", call, 1, RX_USER_ABORT, ECONNABORTED); __rxrpc_abort_call("REJ", call, 1, RX_USER_ABORT, -ECONNABORTED);
abort = true; abort = true;
/* fall through */ /* fall through */
case RXRPC_CALL_COMPLETE: case RXRPC_CALL_COMPLETE:

2
net/rxrpc/call_event.c
View File

@ -386,7 +386,7 @@ recheck_state:
now = ktime_get_real(); now = ktime_get_real();
if (ktime_before(call->expire_at, now)) { if (ktime_before(call->expire_at, now)) {
rxrpc_abort_call("EXP", call, 0, RX_CALL_TIMEOUT, ETIME); rxrpc_abort_call("EXP", call, 0, RX_CALL_TIMEOUT, -ETIME);
set_bit(RXRPC_CALL_EV_ABORT, &call->events); set_bit(RXRPC_CALL_EV_ABORT, &call->events);
goto recheck_state; goto recheck_state;
} }

4
net/rxrpc/call_object.c
View File

@ -486,7 +486,7 @@ void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx)
call = list_entry(rx->to_be_accepted.next, call = list_entry(rx->to_be_accepted.next,
struct rxrpc_call, accept_link); struct rxrpc_call, accept_link);
list_del(&call->accept_link); list_del(&call->accept_link);
rxrpc_abort_call("SKR", call, 0, RX_CALL_DEAD, ECONNRESET); rxrpc_abort_call("SKR", call, 0, RX_CALL_DEAD, -ECONNRESET);
rxrpc_put_call(call, rxrpc_call_put); rxrpc_put_call(call, rxrpc_call_put);
} }
@ -494,7 +494,7 @@ void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx)
call = list_entry(rx->sock_calls.next, call = list_entry(rx->sock_calls.next,
struct rxrpc_call, sock_link); struct rxrpc_call, sock_link);
rxrpc_get_call(call, rxrpc_call_got); rxrpc_get_call(call, rxrpc_call_got);
rxrpc_abort_call("SKT", call, 0, RX_CALL_DEAD, ECONNRESET); rxrpc_abort_call("SKT", call, 0, RX_CALL_DEAD, -ECONNRESET);
rxrpc_send_abort_packet(call); rxrpc_send_abort_packet(call);
rxrpc_release_call(rx, call); rxrpc_release_call(rx, call);
rxrpc_put_call(call, rxrpc_call_put); rxrpc_put_call(call, rxrpc_call_put);

8
net/rxrpc/conn_event.c
View File

@ -168,7 +168,7 @@ static void rxrpc_abort_calls(struct rxrpc_connection *conn,
* generate a connection-level abort * generate a connection-level abort
*/ */
static int rxrpc_abort_connection(struct rxrpc_connection *conn, static int rxrpc_abort_connection(struct rxrpc_connection *conn,
u32 error, u32 abort_code) int error, u32 abort_code)
{ {
struct rxrpc_wire_header whdr; struct rxrpc_wire_header whdr;
struct msghdr msg; struct msghdr msg;
@ -288,7 +288,7 @@ static int rxrpc_process_event(struct rxrpc_connection *conn,
conn->state = RXRPC_CONN_REMOTELY_ABORTED; conn->state = RXRPC_CONN_REMOTELY_ABORTED;
rxrpc_abort_calls(conn, RXRPC_CALL_REMOTELY_ABORTED, rxrpc_abort_calls(conn, RXRPC_CALL_REMOTELY_ABORTED,
abort_code, ECONNABORTED); abort_code, -ECONNABORTED);
return -ECONNABORTED; return -ECONNABORTED;
case RXRPC_PACKET_TYPE_CHALLENGE: case RXRPC_PACKET_TYPE_CHALLENGE:
@ -370,7 +370,7 @@ static void rxrpc_secure_connection(struct rxrpc_connection *conn)
abort: abort:
_debug("abort %d, %d", ret, abort_code); _debug("abort %d, %d", ret, abort_code);
rxrpc_abort_connection(conn, -ret, abort_code); rxrpc_abort_connection(conn, ret, abort_code);
_leave(" [aborted]"); _leave(" [aborted]");
} }
@ -419,7 +419,7 @@ requeue_and_leave:
goto out; goto out;
protocol_error: protocol_error:
if (rxrpc_abort_connection(conn, -ret, abort_code) < 0) if (rxrpc_abort_connection(conn, ret, abort_code) < 0)
goto requeue_and_leave; goto requeue_and_leave;
rxrpc_free_skb(skb, rxrpc_skb_rx_freed); rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
_leave(" [EPROTO]"); _leave(" [EPROTO]");

6
net/rxrpc/input.c
View File

@ -30,7 +30,7 @@
static void rxrpc_proto_abort(const char *why, static void rxrpc_proto_abort(const char *why,
struct rxrpc_call *call, rxrpc_seq_t seq) struct rxrpc_call *call, rxrpc_seq_t seq)
{ {
if (rxrpc_abort_call(why, call, seq, RX_PROTOCOL_ERROR, EBADMSG)) { if (rxrpc_abort_call(why, call, seq, RX_PROTOCOL_ERROR, -EBADMSG)) {
set_bit(RXRPC_CALL_EV_ABORT, &call->events); set_bit(RXRPC_CALL_EV_ABORT, &call->events);
rxrpc_queue_call(call); rxrpc_queue_call(call);
} }
@ -895,7 +895,7 @@ static void rxrpc_input_abort(struct rxrpc_call *call, struct sk_buff *skb)
_proto("Rx ABORT %%%u { %x }", sp->hdr.serial, abort_code); _proto("Rx ABORT %%%u { %x }", sp->hdr.serial, abort_code);
if (rxrpc_set_call_completion(call, RXRPC_CALL_REMOTELY_ABORTED, if (rxrpc_set_call_completion(call, RXRPC_CALL_REMOTELY_ABORTED,
abort_code, ECONNABORTED)) abort_code, -ECONNABORTED))
rxrpc_notify_socket(call); rxrpc_notify_socket(call);
} }
@ -958,7 +958,7 @@ static void rxrpc_input_implicit_end_call(struct rxrpc_connection *conn,
case RXRPC_CALL_COMPLETE: case RXRPC_CALL_COMPLETE:
break; break;
default: default:
if (rxrpc_abort_call("IMP", call, 0, RX_CALL_DEAD, ESHUTDOWN)) { if (rxrpc_abort_call("IMP", call, 0, RX_CALL_DEAD, -ESHUTDOWN)) {
set_bit(RXRPC_CALL_EV_ABORT, &call->events); set_bit(RXRPC_CALL_EV_ABORT, &call->events);
rxrpc_queue_call(call); rxrpc_queue_call(call);
} }

2
net/rxrpc/peer_event.c
View File

@ -296,7 +296,7 @@ void rxrpc_peer_error_distributor(struct work_struct *work)
hlist_del_init(&call->error_link); hlist_del_init(&call->error_link);
rxrpc_see_call(call); rxrpc_see_call(call);
if (rxrpc_set_call_completion(call, compl, 0, error)) if (rxrpc_set_call_completion(call, compl, 0, -error))
rxrpc_notify_socket(call); rxrpc_notify_socket(call);
} }

6
net/rxrpc/recvmsg.c
View File

@ -83,11 +83,11 @@ static int rxrpc_recvmsg_term(struct rxrpc_call *call, struct msghdr *msg)
ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &tmp); ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &tmp);
break; break;
case RXRPC_CALL_NETWORK_ERROR: case RXRPC_CALL_NETWORK_ERROR:
tmp = call->error; tmp = -call->error;
ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NET_ERROR, 4, &tmp); ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NET_ERROR, 4, &tmp);
break; break;
case RXRPC_CALL_LOCAL_ERROR: case RXRPC_CALL_LOCAL_ERROR:
tmp = call->error; tmp = -call->error;
ret = put_cmsg(msg, SOL_RXRPC, RXRPC_LOCAL_ERROR, 4, &tmp); ret = put_cmsg(msg, SOL_RXRPC, RXRPC_LOCAL_ERROR, 4, &tmp);
break; break;
default: default:
@ -689,7 +689,7 @@ excess_data:
goto out; goto out;
call_complete: call_complete:
*_abort = call->abort_code; *_abort = call->abort_code;
ret = -call->error; ret = call->error;
if (call->completion == RXRPC_CALL_SUCCEEDED) { if (call->completion == RXRPC_CALL_SUCCEEDED) {
ret = 1; ret = 1;
if (size > 0) if (size > 0)

18
net/rxrpc/rxkad.c
View File

@ -330,7 +330,7 @@ static int rxkad_verify_packet_1(struct rxrpc_call *call, struct sk_buff *skb,
_enter(""); _enter("");
if (len < 8) { if (len < 8) {
rxrpc_abort_call("V1H", call, seq, RXKADSEALEDINCON, EPROTO); rxrpc_abort_call("V1H", call, seq, RXKADSEALEDINCON, -EPROTO);
goto protocol_error; goto protocol_error;
} }
@ -355,7 +355,7 @@ static int rxkad_verify_packet_1(struct rxrpc_call *call, struct sk_buff *skb,
/* Extract the decrypted packet length */ /* Extract the decrypted packet length */
if (skb_copy_bits(skb, offset, &sechdr, sizeof(sechdr)) < 0) { if (skb_copy_bits(skb, offset, &sechdr, sizeof(sechdr)) < 0) {
rxrpc_abort_call("XV1", call, seq, RXKADDATALEN, EPROTO); rxrpc_abort_call("XV1", call, seq, RXKADDATALEN, -EPROTO);
goto protocol_error; goto protocol_error;
} }
offset += sizeof(sechdr); offset += sizeof(sechdr);
@ -368,12 +368,12 @@ static int rxkad_verify_packet_1(struct rxrpc_call *call, struct sk_buff *skb,
check ^= seq ^ call->call_id; check ^= seq ^ call->call_id;
check &= 0xffff; check &= 0xffff;
if (check != 0) { if (check != 0) {
rxrpc_abort_call("V1C", call, seq, RXKADSEALEDINCON, EPROTO); rxrpc_abort_call("V1C", call, seq, RXKADSEALEDINCON, -EPROTO);
goto protocol_error; goto protocol_error;
} }
if (data_size > len) { if (data_size > len) {
rxrpc_abort_call("V1L", call, seq, RXKADDATALEN, EPROTO); rxrpc_abort_call("V1L", call, seq, RXKADDATALEN, -EPROTO);
goto protocol_error; goto protocol_error;
} }
@ -410,7 +410,7 @@ static int rxkad_verify_packet_2(struct rxrpc_call *call, struct sk_buff *skb,
_enter(",{%d}", skb->len); _enter(",{%d}", skb->len);
if (len < 8) { if (len < 8) {
rxrpc_abort_call("V2H", call, seq, RXKADSEALEDINCON, EPROTO); rxrpc_abort_call("V2H", call, seq, RXKADSEALEDINCON, -EPROTO);
goto protocol_error; goto protocol_error;
} }
@ -445,7 +445,7 @@ static int rxkad_verify_packet_2(struct rxrpc_call *call, struct sk_buff *skb,
/* Extract the decrypted packet length */ /* Extract the decrypted packet length */
if (skb_copy_bits(skb, offset, &sechdr, sizeof(sechdr)) < 0) { if (skb_copy_bits(skb, offset, &sechdr, sizeof(sechdr)) < 0) {
rxrpc_abort_call("XV2", call, seq, RXKADDATALEN, EPROTO); rxrpc_abort_call("XV2", call, seq, RXKADDATALEN, -EPROTO);
goto protocol_error; goto protocol_error;
} }
offset += sizeof(sechdr); offset += sizeof(sechdr);
@ -458,12 +458,12 @@ static int rxkad_verify_packet_2(struct rxrpc_call *call, struct sk_buff *skb,
check ^= seq ^ call->call_id; check ^= seq ^ call->call_id;
check &= 0xffff; check &= 0xffff;
if (check != 0) { if (check != 0) {
rxrpc_abort_call("V2C", call, seq, RXKADSEALEDINCON, EPROTO); rxrpc_abort_call("V2C", call, seq, RXKADSEALEDINCON, -EPROTO);
goto protocol_error; goto protocol_error;
} }
if (data_size > len) { if (data_size > len) {
rxrpc_abort_call("V2L", call, seq, RXKADDATALEN, EPROTO); rxrpc_abort_call("V2L", call, seq, RXKADDATALEN, -EPROTO);
goto protocol_error; goto protocol_error;
} }
@ -522,7 +522,7 @@ static int rxkad_verify_packet(struct rxrpc_call *call, struct sk_buff *skb,
cksum = 1; /* zero checksums are not permitted */ cksum = 1; /* zero checksums are not permitted */
if (cksum != expected_cksum) { if (cksum != expected_cksum) {
rxrpc_abort_call("VCK", call, seq, RXKADSEALEDINCON, EPROTO); rxrpc_abort_call("VCK", call, seq, RXKADSEALEDINCON, -EPROTO);
rxrpc_send_abort_packet(call); rxrpc_send_abort_packet(call);
_leave(" = -EPROTO [csum failed]"); _leave(" = -EPROTO [csum failed]");
return -EPROTO; return -EPROTO;

2
net/rxrpc/sendmsg.c
View File

@ -556,7 +556,7 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len)
ret = -ESHUTDOWN; ret = -ESHUTDOWN;
} else if (cmd == RXRPC_CMD_SEND_ABORT) { } else if (cmd == RXRPC_CMD_SEND_ABORT) {
ret = 0; ret = 0;
if (rxrpc_abort_call("CMD", call, 0, abort_code, ECONNABORTED)) if (rxrpc_abort_call("CMD", call, 0, abort_code, -ECONNABORTED))
ret = rxrpc_send_abort_packet(call); ret = rxrpc_send_abort_packet(call);
} else if (cmd != RXRPC_CMD_SEND_DATA) { } else if (cmd != RXRPC_CMD_SEND_DATA) {
ret = -EINVAL; ret = -EINVAL;