Commit 9103e04b authored by David S. Miller's avatar David S. Miller

Merge tag 'rxrpc-rewrite-20160907-1' of...

Merge tag 'rxrpc-rewrite-20160907-1' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs

David Howells says:

====================
rxrpc: Overhaul call refcounting

Here's a set of mostly small patches leading up to one big one.

The big patch at the end of the series overhauls how rxrpc_call refcounting
is handled, making it more sane so that calls bound to user IDs are _only_
released from socket operations or kernel API functions.  Further, the
patch stops calls from holding refs on their parent socket - which can
prevent the socket from being cleaned up.

The second largest patch improves the call tracking tracepoint by providing
extra information about the situation in which gets and puts occur.  This
allows distinctions to be drawn between refs held by the socket user ID
tree, refs held by the work queue (to be implemented by a future patch) and
other refs.

The other patches include a couple of cleanups and some simple alterations
to avoid NULL pointer dereferences in the big patch.
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents cf86799e 8d94aa38
...@@ -17,7 +17,8 @@ ...@@ -17,7 +17,8 @@
#include <linux/tracepoint.h> #include <linux/tracepoint.h>
TRACE_EVENT(rxrpc_call, TRACE_EVENT(rxrpc_call,
TP_PROTO(struct rxrpc_call *call, int op, int usage, int nskb, TP_PROTO(struct rxrpc_call *call, enum rxrpc_call_trace op,
int usage, int nskb,
const void *where, const void *aux), const void *where, const void *aux),
TP_ARGS(call, op, usage, nskb, where, aux), TP_ARGS(call, op, usage, nskb, where, aux),
...@@ -42,13 +43,7 @@ TRACE_EVENT(rxrpc_call, ...@@ -42,13 +43,7 @@ TRACE_EVENT(rxrpc_call,
TP_printk("c=%p %s u=%d s=%d p=%pSR a=%p", TP_printk("c=%p %s u=%d s=%d p=%pSR a=%p",
__entry->call, __entry->call,
(__entry->op == 0 ? "NWc" : rxrpc_call_traces[__entry->op],
__entry->op == 1 ? "NWs" :
__entry->op == 2 ? "SEE" :
__entry->op == 3 ? "GET" :
__entry->op == 4 ? "Gsb" :
__entry->op == 5 ? "PUT" :
"Psb"),
__entry->usage, __entry->usage,
__entry->nskb, __entry->nskb,
__entry->where, __entry->where,
......
...@@ -294,9 +294,8 @@ EXPORT_SYMBOL(rxrpc_kernel_begin_call); ...@@ -294,9 +294,8 @@ EXPORT_SYMBOL(rxrpc_kernel_begin_call);
void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call) void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call)
{ {
_enter("%d{%d}", call->debug_id, atomic_read(&call->usage)); _enter("%d{%d}", call->debug_id, atomic_read(&call->usage));
rxrpc_remove_user_ID(rxrpc_sk(sock->sk), call); rxrpc_release_call(rxrpc_sk(sock->sk), call);
rxrpc_purge_queue(&call->knlrecv_queue); rxrpc_put_call(call, rxrpc_call_put);
rxrpc_put_call(call);
} }
EXPORT_SYMBOL(rxrpc_kernel_end_call); EXPORT_SYMBOL(rxrpc_kernel_end_call);
...@@ -558,6 +557,7 @@ static int rxrpc_create(struct net *net, struct socket *sock, int protocol, ...@@ -558,6 +557,7 @@ static int rxrpc_create(struct net *net, struct socket *sock, int protocol,
return -ENOMEM; return -ENOMEM;
sock_init_data(sock, sk); sock_init_data(sock, sk);
sock_set_flag(sk, SOCK_RCU_FREE);
sk->sk_state = RXRPC_UNBOUND; sk->sk_state = RXRPC_UNBOUND;
sk->sk_write_space = rxrpc_write_space; sk->sk_write_space = rxrpc_write_space;
sk->sk_max_ack_backlog = 0; sk->sk_max_ack_backlog = 0;
......
...@@ -35,8 +35,6 @@ struct rxrpc_crypt { ...@@ -35,8 +35,6 @@ struct rxrpc_crypt {
#define rxrpc_queue_delayed_work(WS,D) \ #define rxrpc_queue_delayed_work(WS,D) \
queue_delayed_work(rxrpc_workqueue, (WS), (D)) queue_delayed_work(rxrpc_workqueue, (WS), (D))
#define rxrpc_queue_call(CALL) rxrpc_queue_work(&(CALL)->processor)
struct rxrpc_connection; struct rxrpc_connection;
/* /*
...@@ -397,7 +395,6 @@ enum rxrpc_call_event { ...@@ -397,7 +395,6 @@ enum rxrpc_call_event {
RXRPC_CALL_EV_ACCEPTED, /* incoming call accepted by userspace app */ RXRPC_CALL_EV_ACCEPTED, /* incoming call accepted by userspace app */
RXRPC_CALL_EV_SECURED, /* incoming call's connection is now secure */ RXRPC_CALL_EV_SECURED, /* incoming call's connection is now secure */
RXRPC_CALL_EV_POST_ACCEPT, /* need to post an "accept?" message to the app */ RXRPC_CALL_EV_POST_ACCEPT, /* need to post an "accept?" message to the app */
RXRPC_CALL_EV_RELEASE, /* need to release the call's resources */
}; };
/* /*
...@@ -417,7 +414,6 @@ enum rxrpc_call_state { ...@@ -417,7 +414,6 @@ enum rxrpc_call_state {
RXRPC_CALL_SERVER_SEND_REPLY, /* - server sending reply */ RXRPC_CALL_SERVER_SEND_REPLY, /* - server sending reply */
RXRPC_CALL_SERVER_AWAIT_ACK, /* - server awaiting final ACK */ RXRPC_CALL_SERVER_AWAIT_ACK, /* - server awaiting final ACK */
RXRPC_CALL_COMPLETE, /* - call complete */ RXRPC_CALL_COMPLETE, /* - call complete */
RXRPC_CALL_DEAD, /* - call is dead */
NR__RXRPC_CALL_STATES NR__RXRPC_CALL_STATES
}; };
...@@ -442,12 +438,10 @@ struct rxrpc_call { ...@@ -442,12 +438,10 @@ struct rxrpc_call {
struct rcu_head rcu; struct rcu_head rcu;
struct rxrpc_connection *conn; /* connection carrying call */ struct rxrpc_connection *conn; /* connection carrying call */
struct rxrpc_peer *peer; /* Peer record for remote address */ struct rxrpc_peer *peer; /* Peer record for remote address */
struct rxrpc_sock *socket; /* socket responsible */ struct rxrpc_sock __rcu *socket; /* socket responsible */
struct timer_list lifetimer; /* lifetime remaining on call */ struct timer_list lifetimer; /* lifetime remaining on call */
struct timer_list deadspan; /* reap timer for re-ACK'ing, etc */
struct timer_list ack_timer; /* ACK generation timer */ struct timer_list ack_timer; /* ACK generation timer */
struct timer_list resend_timer; /* Tx resend timer */ struct timer_list resend_timer; /* Tx resend timer */
struct work_struct destroyer; /* call destroyer */
struct work_struct processor; /* packet processor and ACK generator */ struct work_struct processor; /* packet processor and ACK generator */
rxrpc_notify_rx_t notify_rx; /* kernel service Rx notification function */ rxrpc_notify_rx_t notify_rx; /* kernel service Rx notification function */
struct list_head link; /* link in master call list */ struct list_head link; /* link in master call list */
...@@ -475,6 +469,7 @@ struct rxrpc_call { ...@@ -475,6 +469,7 @@ struct rxrpc_call {
atomic_t skb_count; /* Outstanding packets on this call */ atomic_t skb_count; /* Outstanding packets on this call */
atomic_t sequence; /* Tx data packet sequence counter */ atomic_t sequence; /* Tx data packet sequence counter */
u16 service_id; /* service ID */ u16 service_id; /* service ID */
u8 security_ix; /* Security type */
u32 call_id; /* call ID on connection */ u32 call_id; /* call ID on connection */
u32 cid; /* connection ID plus channel index */ u32 cid; /* connection ID plus channel index */
int debug_id; /* debug ID for printks */ int debug_id; /* debug ID for printks */
...@@ -508,6 +503,24 @@ struct rxrpc_call { ...@@ -508,6 +503,24 @@ struct rxrpc_call {
unsigned long ackr_window[RXRPC_ACKR_WINDOW_ASZ + 1]; unsigned long ackr_window[RXRPC_ACKR_WINDOW_ASZ + 1];
}; };
enum rxrpc_call_trace {
rxrpc_call_new_client,
rxrpc_call_new_service,
rxrpc_call_queued,
rxrpc_call_queued_ref,
rxrpc_call_seen,
rxrpc_call_got,
rxrpc_call_got_skb,
rxrpc_call_got_userid,
rxrpc_call_put,
rxrpc_call_put_skb,
rxrpc_call_put_userid,
rxrpc_call_put_noqueue,
rxrpc_call__nr_trace
};
extern const char rxrpc_call_traces[rxrpc_call__nr_trace][4];
#include <trace/events/rxrpc.h> #include <trace/events/rxrpc.h>
/* /*
...@@ -539,7 +552,6 @@ void rxrpc_process_call(struct work_struct *); ...@@ -539,7 +552,6 @@ void rxrpc_process_call(struct work_struct *);
extern const char *const rxrpc_call_states[]; extern const char *const rxrpc_call_states[];
extern const char *const rxrpc_call_completions[]; extern const char *const rxrpc_call_completions[];
extern unsigned int rxrpc_max_call_lifetime; extern unsigned int rxrpc_max_call_lifetime;
extern unsigned int rxrpc_dead_call_expiry;
extern struct kmem_cache *rxrpc_call_jar; extern struct kmem_cache *rxrpc_call_jar;
extern struct list_head rxrpc_calls; extern struct list_head rxrpc_calls;
extern rwlock_t rxrpc_call_lock; extern rwlock_t rxrpc_call_lock;
...@@ -552,11 +564,13 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *, ...@@ -552,11 +564,13 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *,
struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *, struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *,
struct rxrpc_connection *, struct rxrpc_connection *,
struct sk_buff *); struct sk_buff *);
void rxrpc_release_call(struct rxrpc_call *); void rxrpc_release_call(struct rxrpc_sock *, struct rxrpc_call *);
void rxrpc_release_calls_on_socket(struct rxrpc_sock *); void rxrpc_release_calls_on_socket(struct rxrpc_sock *);
bool __rxrpc_queue_call(struct rxrpc_call *);
bool rxrpc_queue_call(struct rxrpc_call *);
void rxrpc_see_call(struct rxrpc_call *); void rxrpc_see_call(struct rxrpc_call *);
void rxrpc_get_call(struct rxrpc_call *); void rxrpc_get_call(struct rxrpc_call *, enum rxrpc_call_trace);
void rxrpc_put_call(struct rxrpc_call *); void rxrpc_put_call(struct rxrpc_call *, enum rxrpc_call_trace);
void rxrpc_get_call_for_skb(struct rxrpc_call *, struct sk_buff *); void rxrpc_get_call_for_skb(struct rxrpc_call *, struct sk_buff *);
void rxrpc_put_call_for_skb(struct rxrpc_call *, struct sk_buff *); void rxrpc_put_call_for_skb(struct rxrpc_call *, struct sk_buff *);
void __exit rxrpc_destroy_all_calls(void); void __exit rxrpc_destroy_all_calls(void);
...@@ -720,7 +734,6 @@ static inline void rxrpc_put_connection(struct rxrpc_connection *conn) ...@@ -720,7 +734,6 @@ static inline void rxrpc_put_connection(struct rxrpc_connection *conn)
} }
} }
static inline bool rxrpc_queue_conn(struct rxrpc_connection *conn) static inline bool rxrpc_queue_conn(struct rxrpc_connection *conn)
{ {
if (!rxrpc_get_connection_maybe(conn)) if (!rxrpc_get_connection_maybe(conn))
...@@ -817,6 +830,7 @@ extern const char *rxrpc_acks(u8 reason); ...@@ -817,6 +830,7 @@ extern const char *rxrpc_acks(u8 reason);
/* /*
* output.c * output.c
*/ */
int rxrpc_send_call_packet(struct rxrpc_call *, u8);
int rxrpc_send_data_packet(struct rxrpc_connection *, struct sk_buff *); int rxrpc_send_data_packet(struct rxrpc_connection *, struct sk_buff *);
/* /*
...@@ -862,7 +876,6 @@ extern const struct file_operations rxrpc_connection_seq_fops; ...@@ -862,7 +876,6 @@ extern const struct file_operations rxrpc_connection_seq_fops;
/* /*
* recvmsg.c * recvmsg.c
*/ */
void rxrpc_remove_user_ID(struct rxrpc_sock *, struct rxrpc_call *);
int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int); int rxrpc_recvmsg(struct socket *, struct msghdr *, size_t, int);
/* /*
...@@ -879,7 +892,7 @@ int __init rxrpc_init_security(void); ...@@ -879,7 +892,7 @@ int __init rxrpc_init_security(void);
void rxrpc_exit_security(void); void rxrpc_exit_security(void);
int rxrpc_init_client_conn_security(struct rxrpc_connection *); int rxrpc_init_client_conn_security(struct rxrpc_connection *);
int rxrpc_init_server_conn_security(struct rxrpc_connection *); int rxrpc_init_server_conn_security(struct rxrpc_connection *);
/* /*
* sendmsg.c * sendmsg.c
*/ */
......
...@@ -115,7 +115,7 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local, ...@@ -115,7 +115,7 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local,
write_lock(&rx->call_lock); write_lock(&rx->call_lock);
if (!test_and_set_bit(RXRPC_CALL_INIT_ACCEPT, &call->flags)) { if (!test_and_set_bit(RXRPC_CALL_INIT_ACCEPT, &call->flags)) {
rxrpc_get_call(call); rxrpc_get_call(call, rxrpc_call_got);
spin_lock(&call->conn->state_lock); spin_lock(&call->conn->state_lock);
if (sp->hdr.securityIndex > 0 && if (sp->hdr.securityIndex > 0 &&
...@@ -155,7 +155,7 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local, ...@@ -155,7 +155,7 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local,
_debug("done"); _debug("done");
read_unlock_bh(&local->services_lock); read_unlock_bh(&local->services_lock);
rxrpc_free_skb(notification); rxrpc_free_skb(notification);
rxrpc_put_call(call); rxrpc_put_call(call, rxrpc_call_put);
_leave(" = 0"); _leave(" = 0");
return 0; return 0;
...@@ -163,14 +163,8 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local, ...@@ -163,14 +163,8 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local,
_debug("invalid"); _debug("invalid");
read_unlock_bh(&local->services_lock); read_unlock_bh(&local->services_lock);
read_lock_bh(&call->state_lock); rxrpc_release_call(rx, call);
if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) && rxrpc_put_call(call, rxrpc_call_put);
!test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events)) {
rxrpc_get_call(call);
rxrpc_queue_call(call);
}
read_unlock_bh(&call->state_lock);
rxrpc_put_call(call);
ret = -ECONNREFUSED; ret = -ECONNREFUSED;
error: error:
rxrpc_free_skb(notification); rxrpc_free_skb(notification);
...@@ -236,13 +230,11 @@ void rxrpc_accept_incoming_calls(struct rxrpc_local *local) ...@@ -236,13 +230,11 @@ void rxrpc_accept_incoming_calls(struct rxrpc_local *local)
if (sk_acceptq_is_full(&rx->sk)) if (sk_acceptq_is_full(&rx->sk))
goto backlog_full; goto backlog_full;
sk_acceptq_added(&rx->sk); sk_acceptq_added(&rx->sk);
sock_hold(&rx->sk);
read_unlock_bh(&local->services_lock); read_unlock_bh(&local->services_lock);
ret = rxrpc_accept_incoming_call(local, rx, skb, &srx); ret = rxrpc_accept_incoming_call(local, rx, skb, &srx);
if (ret < 0) if (ret < 0)
sk_acceptq_removed(&rx->sk); sk_acceptq_removed(&rx->sk);
sock_put(&rx->sk);
switch (ret) { switch (ret) {
case -ECONNRESET: /* old calls are ignored */ case -ECONNRESET: /* old calls are ignored */
case -ECONNABORTED: /* aborted calls are reaborted or ignored */ case -ECONNABORTED: /* aborted calls are reaborted or ignored */
...@@ -333,14 +325,12 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx, ...@@ -333,14 +325,12 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx,
case RXRPC_CALL_COMPLETE: case RXRPC_CALL_COMPLETE:
ret = call->error; ret = call->error;
goto out_release; goto out_release;
case RXRPC_CALL_DEAD:
ret = -ETIME;
goto out_discard;
default: default:
BUG(); BUG();
} }
/* formalise the acceptance */ /* formalise the acceptance */
rxrpc_get_call(call, rxrpc_call_got_userid);
call->notify_rx = notify_rx; call->notify_rx = notify_rx;
call->user_call_ID = user_call_ID; call->user_call_ID = user_call_ID;
rb_link_node(&call->sock_node, parent, pp); rb_link_node(&call->sock_node, parent, pp);
...@@ -349,25 +339,20 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx, ...@@ -349,25 +339,20 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx,
BUG(); BUG();
if (test_and_set_bit(RXRPC_CALL_EV_ACCEPTED, &call->events)) if (test_and_set_bit(RXRPC_CALL_EV_ACCEPTED, &call->events))
BUG(); BUG();
rxrpc_queue_call(call);
rxrpc_get_call(call);
write_unlock_bh(&call->state_lock); write_unlock_bh(&call->state_lock);
write_unlock(&rx->call_lock); write_unlock(&rx->call_lock);
rxrpc_queue_call(call);
_leave(" = %p{%d}", call, call->debug_id); _leave(" = %p{%d}", call, call->debug_id);
return call; return call;
/* if the call is already dying or dead, then we leave the socket's ref
* on it to be released by rxrpc_dead_call_expired() as induced by
* rxrpc_release_call() */
out_release: out_release:
_debug("release %p", call);
if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
!test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))
rxrpc_queue_call(call);
out_discard:
write_unlock_bh(&call->state_lock); write_unlock_bh(&call->state_lock);
_debug("discard %p", call); write_unlock(&rx->call_lock);
_debug("release %p", call);
rxrpc_release_call(rx, call);
_leave(" = %d", ret);
return ERR_PTR(ret);
out: out:
write_unlock(&rx->call_lock); write_unlock(&rx->call_lock);
_leave(" = %d", ret); _leave(" = %d", ret);
...@@ -390,8 +375,11 @@ int rxrpc_reject_call(struct rxrpc_sock *rx) ...@@ -390,8 +375,11 @@ int rxrpc_reject_call(struct rxrpc_sock *rx)
write_lock(&rx->call_lock); write_lock(&rx->call_lock);
ret = -ENODATA; ret = -ENODATA;
if (list_empty(&rx->acceptq)) if (list_empty(&rx->acceptq)) {
goto out; write_unlock(&rx->call_lock);
_leave(" = -ENODATA");
return -ENODATA;
}
/* dequeue the first call and check it's still valid */ /* dequeue the first call and check it's still valid */
call = list_entry(rx->acceptq.next, struct rxrpc_call, accept_link); call = list_entry(rx->acceptq.next, struct rxrpc_call, accept_link);
...@@ -407,30 +395,17 @@ int rxrpc_reject_call(struct rxrpc_sock *rx) ...@@ -407,30 +395,17 @@ int rxrpc_reject_call(struct rxrpc_sock *rx)
if (test_and_set_bit(RXRPC_CALL_EV_REJECT_BUSY, &call->events)) if (test_and_set_bit(RXRPC_CALL_EV_REJECT_BUSY, &call->events))
rxrpc_queue_call(call); rxrpc_queue_call(call);
ret = 0; ret = 0;
goto out_release; break;
case RXRPC_CALL_COMPLETE: case RXRPC_CALL_COMPLETE:
ret = call->error; ret = call->error;
goto out_release; break;
case RXRPC_CALL_DEAD:
ret = -ETIME;
goto out_discard;
default: default:
BUG(); BUG();
} }
/* if the call is already dying or dead, then we leave the socket's ref
* on it to be released by rxrpc_dead_call_expired() as induced by
* rxrpc_release_call() */
out_release:
_debug("release %p", call);
if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
!test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))
rxrpc_queue_call(call);
out_discard:
write_unlock_bh(&call->state_lock); write_unlock_bh(&call->state_lock);
_debug("discard %p", call);
out:
write_unlock(&rx->call_lock); write_unlock(&rx->call_lock);
rxrpc_release_call(rx, call);
_leave(" = %d", ret); _leave(" = %d", ret);
return ret; return ret;
} }
......
...@@ -811,8 +811,9 @@ static int rxrpc_post_message(struct rxrpc_call *call, u32 mark, u32 error, ...@@ -811,8 +811,9 @@ static int rxrpc_post_message(struct rxrpc_call *call, u32 mark, u32 error,
} }
/* /*
* handle background processing of incoming call packets and ACK / abort * Handle background processing of incoming call packets and ACK / abort
* generation * generation. A ref on the call is donated to us by whoever queued the work
* item.
*/ */
void rxrpc_process_call(struct work_struct *work) void rxrpc_process_call(struct work_struct *work)
{ {
...@@ -827,6 +828,7 @@ void rxrpc_process_call(struct work_struct *work) ...@@ -827,6 +828,7 @@ void rxrpc_process_call(struct work_struct *work)
unsigned long bits; unsigned long bits;
__be32 data, pad; __be32 data, pad;
size_t len; size_t len;
bool requeue = false;
int loop, nbit, ioc, ret, mtu; int loop, nbit, ioc, ret, mtu;
u32 serial, abort_code = RX_PROTOCOL_ERROR; u32 serial, abort_code = RX_PROTOCOL_ERROR;
u8 *acks = NULL; u8 *acks = NULL;
...@@ -838,6 +840,11 @@ void rxrpc_process_call(struct work_struct *work) ...@@ -838,6 +840,11 @@ void rxrpc_process_call(struct work_struct *work)
call->debug_id, rxrpc_call_states[call->state], call->events, call->debug_id, rxrpc_call_states[call->state], call->events,
(jiffies - call->creation_jif) / (HZ / 10)); (jiffies - call->creation_jif) / (HZ / 10));
if (call->state >= RXRPC_CALL_COMPLETE) {
rxrpc_put_call(call, rxrpc_call_put);
return;
}
if (!call->conn) if (!call->conn)
goto skip_msg_init; goto skip_msg_init;
...@@ -1088,16 +1095,21 @@ void rxrpc_process_call(struct work_struct *work) ...@@ -1088,16 +1095,21 @@ void rxrpc_process_call(struct work_struct *work)
spin_lock_bh(&call->lock); spin_lock_bh(&call->lock);
if (call->state == RXRPC_CALL_SERVER_SECURING) { if (call->state == RXRPC_CALL_SERVER_SECURING) {
struct rxrpc_sock *rx;
_debug("securing"); _debug("securing");
write_lock(&call->socket->call_lock); rcu_read_lock();
if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) && rx = rcu_dereference(call->socket);
!test_bit(RXRPC_CALL_EV_RELEASE, &call->events)) { if (rx) {
_debug("not released"); write_lock(&rx->call_lock);
call->state = RXRPC_CALL_SERVER_ACCEPTING; if (!test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
list_move_tail(&call->accept_link, _debug("not released");
&call->socket->acceptq); call->state = RXRPC_CALL_SERVER_ACCEPTING;
list_move_tail(&call->accept_link,
&rx->acceptq);
}
write_unlock(&rx->call_lock);
} }
write_unlock(&call->socket->call_lock); rcu_read_unlock();
read_lock(&call->state_lock); read_lock(&call->state_lock);
if (call->state < RXRPC_CALL_COMPLETE) if (call->state < RXRPC_CALL_COMPLETE)
set_bit(RXRPC_CALL_EV_POST_ACCEPT, &call->events); set_bit(RXRPC_CALL_EV_POST_ACCEPT, &call->events);
...@@ -1139,11 +1151,6 @@ void rxrpc_process_call(struct work_struct *work) ...@@ -1139,11 +1151,6 @@ void rxrpc_process_call(struct work_struct *work)
goto maybe_reschedule; goto maybe_reschedule;
} }
if (test_bit(RXRPC_CALL_EV_RELEASE, &call->events)) {
rxrpc_release_call(call);
clear_bit(RXRPC_CALL_EV_RELEASE, &call->events);
}
/* other events may have been raised since we started checking */ /* other events may have been raised since we started checking */
goto maybe_reschedule; goto maybe_reschedule;
...@@ -1209,10 +1216,8 @@ void rxrpc_process_call(struct work_struct *work) ...@@ -1209,10 +1216,8 @@ void rxrpc_process_call(struct work_struct *work)
&msg, iov, ioc, len); &msg, iov, ioc, len);
if (ret < 0) { if (ret < 0) {
_debug("sendmsg failed: %d", ret); _debug("sendmsg failed: %d", ret);
read_lock_bh(&call->state_lock); if (call->state < RXRPC_CALL_COMPLETE)
if (call->state < RXRPC_CALL_DEAD) requeue = true;
rxrpc_queue_call(call);
read_unlock_bh(&call->state_lock);
goto error; goto error;
} }
...@@ -1245,41 +1250,22 @@ void rxrpc_process_call(struct work_struct *work) ...@@ -1245,41 +1250,22 @@ void rxrpc_process_call(struct work_struct *work)
kill_ACKs: kill_ACKs:
del_timer_sync(&call->ack_timer); del_timer_sync(&call->ack_timer);
if (test_and_clear_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events))
rxrpc_put_call(call);
clear_bit(RXRPC_CALL_EV_ACK, &call->events); clear_bit(RXRPC_CALL_EV_ACK, &call->events);
maybe_reschedule: maybe_reschedule:
if (call->events || !skb_queue_empty(&call->rx_queue)) { if (call->events || !skb_queue_empty(&call->rx_queue)) {
read_lock_bh(&call->state_lock); if (call->state < RXRPC_CALL_COMPLETE)
if (call->state < RXRPC_CALL_DEAD) requeue = true;
rxrpc_queue_call(call);
read_unlock_bh(&call->state_lock);
}
/* don't leave aborted connections on the accept queue */
if (call->state >= RXRPC_CALL_COMPLETE &&
!list_empty(&call->accept_link)) {
_debug("X unlinking once-pending call %p { e=%lx f=%lx c=%x }",
call, call->events, call->flags, call->conn->proto.cid);
read_lock_bh(&call->state_lock);
if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
!test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))
rxrpc_queue_call(call);
read_unlock_bh(&call->state_lock);
} }
error: error:
kfree(acks); kfree(acks);
/* because we don't want two CPUs both processing the work item for one if ((requeue || call->events) && !work_pending(&call->processor)) {
* call at the same time, we use a flag to note when it's busy; however
* this means there's a race between clearing the flag and setting the
* work pending bit and the work item being processed again */
if (call->events && !work_pending(&call->processor)) {
_debug("jumpstart %x", call->conn->proto.cid); _debug("jumpstart %x", call->conn->proto.cid);
rxrpc_queue_call(call); __rxrpc_queue_call(call);
} else {
rxrpc_put_call(call, rxrpc_call_put);
} }
_leave(""); _leave("");
......
...@@ -24,11 +24,6 @@ ...@@ -24,11 +24,6 @@
*/ */
unsigned int rxrpc_max_call_lifetime = 60 * HZ; unsigned int rxrpc_max_call_lifetime = 60 * HZ;
/*
* Time till dead call expires after last use (in jiffies).
*/
unsigned int rxrpc_dead_call_expiry = 2 * HZ;
const char *const rxrpc_call_states[NR__RXRPC_CALL_STATES] = { const char *const rxrpc_call_states[NR__RXRPC_CALL_STATES] = {
[RXRPC_CALL_UNINITIALISED] = "Uninit ", [RXRPC_CALL_UNINITIALISED] = "Uninit ",
[RXRPC_CALL_CLIENT_AWAIT_CONN] = "ClWtConn", [RXRPC_CALL_CLIENT_AWAIT_CONN] = "ClWtConn",
...@@ -43,7 +38,6 @@ const char *const rxrpc_call_states[NR__RXRPC_CALL_STATES] = { ...@@ -43,7 +38,6 @@ const char *const rxrpc_call_states[NR__RXRPC_CALL_STATES] = {
[RXRPC_CALL_SERVER_SEND_REPLY] = "SvSndRpl", [RXRPC_CALL_SERVER_SEND_REPLY] = "SvSndRpl",
[RXRPC_CALL_SERVER_AWAIT_ACK] = "SvAwtACK", [RXRPC_CALL_SERVER_AWAIT_ACK] = "SvAwtACK",
[RXRPC_CALL_COMPLETE] = "Complete", [RXRPC_CALL_COMPLETE] = "Complete",
[RXRPC_CALL_DEAD] = "Dead ",
}; };
const char *const rxrpc_call_completions[NR__RXRPC_CALL_COMPLETIONS] = { const char *const rxrpc_call_completions[NR__RXRPC_CALL_COMPLETIONS] = {
...@@ -55,15 +49,29 @@ const char *const rxrpc_call_completions[NR__RXRPC_CALL_COMPLETIONS] = { ...@@ -55,15 +49,29 @@ const char *const rxrpc_call_completions[NR__RXRPC_CALL_COMPLETIONS] = {
[RXRPC_CALL_NETWORK_ERROR] = "NetError", [RXRPC_CALL_NETWORK_ERROR] = "NetError",
}; };
const char rxrpc_call_traces[rxrpc_call__nr_trace][4] = {
[rxrpc_call_new_client] = "NWc",
[rxrpc_call_new_service] = "NWs",
[rxrpc_call_queued] = "QUE",
[rxrpc_call_queued_ref] = "QUR",
[rxrpc_call_seen] = "SEE",
[rxrpc_call_got] = "GOT",
[rxrpc_call_got_skb] = "Gsk",
[rxrpc_call_got_userid] = "Gus",
[rxrpc_call_put] = "PUT",
[rxrpc_call_put_skb] = "Psk",
[rxrpc_call_put_userid] = "Pus",
[rxrpc_call_put_noqueue] = "PNQ",
};
struct kmem_cache *rxrpc_call_jar; struct kmem_cache *rxrpc_call_jar;
LIST_HEAD(rxrpc_calls); LIST_HEAD(rxrpc_calls);
DEFINE_RWLOCK(rxrpc_call_lock); DEFINE_RWLOCK(rxrpc_call_lock);
static void rxrpc_destroy_call(struct work_struct *work);
static void rxrpc_call_life_expired(unsigned long _call); static void rxrpc_call_life_expired(unsigned long _call);
static void rxrpc_dead_call_expired(unsigned long _call);
static void rxrpc_ack_time_expired(unsigned long _call); static void rxrpc_ack_time_expired(unsigned long _call);
static void rxrpc_resend_time_expired(unsigned long _call); static void rxrpc_resend_time_expired(unsigned long _call);
static void rxrpc_cleanup_call(struct rxrpc_call *call);
/* /*
* find an extant server call * find an extant server call
...@@ -96,7 +104,7 @@ struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *rx, ...@@ -96,7 +104,7 @@ struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *rx,
return NULL; return NULL;
found_extant_call: found_extant_call:
rxrpc_get_call(call); rxrpc_get_call(call, rxrpc_call_got);
read_unlock(&rx->call_lock); read_unlock(&rx->call_lock);
_leave(" = %p [%d]", call, atomic_read(&call->usage)); _leave(" = %p [%d]", call, atomic_read(&call->usage));
return call; return call;
...@@ -123,13 +131,10 @@ static struct rxrpc_call *rxrpc_alloc_call(gfp_t gfp) ...@@ -123,13 +131,10 @@ static struct rxrpc_call *rxrpc_alloc_call(gfp_t gfp)
setup_timer(&call->lifetimer, &rxrpc_call_life_expired, setup_timer(&call->lifetimer, &rxrpc_call_life_expired,
(unsigned long) call); (unsigned long) call);
setup_timer(&call->deadspan, &rxrpc_dead_call_expired,
(unsigned long) call);
setup_timer(&call->ack_timer, &rxrpc_ack_time_expired, setup_timer(&call->ack_timer, &rxrpc_ack_time_expired,
(unsigned long) call); (unsigned long) call);
setup_timer(&call->resend_timer, &rxrpc_resend_time_expired, setup_timer(&call->resend_timer, &rxrpc_resend_time_expired,
(unsigned long) call); (unsigned long) call);
INIT_WORK(&call->destroyer, &rxrpc_destroy_call);
INIT_WORK(&call->processor, &rxrpc_process_call); INIT_WORK(&call->processor, &rxrpc_process_call);
INIT_LIST_HEAD(&call->link); INIT_LIST_HEAD(&call->link);
INIT_LIST_HEAD(&call->chan_wait_link); INIT_LIST_HEAD(&call->chan_wait_link);
...@@ -170,11 +175,9 @@ static struct rxrpc_call *rxrpc_alloc_client_call(struct rxrpc_sock *rx, ...@@ -170,11 +175,9 @@ static struct rxrpc_call *rxrpc_alloc_client_call(struct rxrpc_sock *rx,
if (!call) if (!call)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
call->state = RXRPC_CALL_CLIENT_AWAIT_CONN; call->state = RXRPC_CALL_CLIENT_AWAIT_CONN;
sock_hold(&rx->sk);
call->socket = rx;
call->rx_data_post = 1; call->rx_data_post = 1;
call->service_id = srx->srx_service; call->service_id = srx->srx_service;
rcu_assign_pointer(call->socket, rx);
_leave(" = %p", call); _leave(" = %p", call);
return call; return call;
...@@ -229,8 +232,9 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx, ...@@ -229,8 +232,9 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx,
return call; return call;
} }
trace_rxrpc_call(call, 0, atomic_read(&call->usage), 0, here, trace_rxrpc_call(call, rxrpc_call_new_client,
(const void *)user_call_ID); atomic_read(&call->usage), 0,
here, (const void *)user_call_ID);
/* Publish the call, even though it is incompletely set up as yet */ /* Publish the call, even though it is incompletely set up as yet */
call->user_call_ID = user_call_ID; call->user_call_ID = user_call_ID;
...@@ -252,8 +256,7 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx, ...@@ -252,8 +256,7 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx,
goto found_user_ID_now_present; goto found_user_ID_now_present;
} }
rxrpc_get_call(call); rxrpc_get_call(call, rxrpc_call_got_userid);
rb_link_node(&call->sock_node, parent, pp); rb_link_node(&call->sock_node, parent, pp);
rb_insert_color(&call->sock_node, &rx->calls); rb_insert_color(&call->sock_node, &rx->calls);
write_unlock(&rx->call_lock); write_unlock(&rx->call_lock);
...@@ -275,15 +278,17 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx, ...@@ -275,15 +278,17 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx,
write_lock(&rx->call_lock); write_lock(&rx->call_lock);
rb_erase(&call->sock_node, &rx->calls); rb_erase(&call->sock_node, &rx->calls);
write_unlock(&rx->call_lock); write_unlock(&rx->call_lock);
rxrpc_put_call(call); rxrpc_put_call(call, rxrpc_call_put_userid);
write_lock_bh(&rxrpc_call_lock); write_lock_bh(&rxrpc_call_lock);
list_del_init(&call->link); list_del_init(&call->link);
write_unlock_bh(&rxrpc_call_lock); write_unlock_bh(&rxrpc_call_lock);
error_out:
__rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR,
RX_CALL_DEAD, ret);
set_bit(RXRPC_CALL_RELEASED, &call->flags); set_bit(RXRPC_CALL_RELEASED, &call->flags);
call->state = RXRPC_CALL_DEAD; rxrpc_put_call(call, rxrpc_call_put);
rxrpc_put_call(call);
_leave(" = %d", ret); _leave(" = %d", ret);
return ERR_PTR(ret); return ERR_PTR(ret);
...@@ -294,11 +299,8 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx, ...@@ -294,11 +299,8 @@ struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx,
*/ */
found_user_ID_now_present: found_user_ID_now_present:
write_unlock(&rx->call_lock); write_unlock(&rx->call_lock);
set_bit(RXRPC_CALL_RELEASED, &call->flags); ret = -EEXIST;
call->state = RXRPC_CALL_DEAD; goto error_out;
rxrpc_put_call(call);
_leave(" = -EEXIST [%p]", call);
return ERR_PTR(-EEXIST);
} }
/* /*
...@@ -322,20 +324,21 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx, ...@@ -322,20 +324,21 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx,
if (!candidate) if (!candidate)
return ERR_PTR(-EBUSY); return ERR_PTR(-EBUSY);
trace_rxrpc_call(candidate, 1, atomic_read(&candidate->usage), trace_rxrpc_call(candidate, rxrpc_call_new_service,
0, here, NULL); atomic_read(&candidate->usage), 0, here, NULL);
chan = sp->hdr.cid & RXRPC_CHANNELMASK; chan = sp->hdr.cid & RXRPC_CHANNELMASK;
candidate->socket = rx;
candidate->conn = conn; candidate->conn = conn;
candidate->peer = conn->params.peer; candidate->peer = conn->params.peer;
candidate->cid = sp->hdr.cid; candidate->cid = sp->hdr.cid;
candidate->call_id = sp->hdr.callNumber; candidate->call_id = sp->hdr.callNumber;
candidate->security_ix = sp->hdr.securityIndex;
candidate->rx_data_post = 0; candidate->rx_data_post = 0;
candidate->state = RXRPC_CALL_SERVER_ACCEPTING; candidate->state = RXRPC_CALL_SERVER_ACCEPTING;
candidate->flags |= (1 << RXRPC_CALL_IS_SERVICE); candidate->flags |= (1 << RXRPC_CALL_IS_SERVICE);
if (conn->security_ix > 0) if (conn->security_ix > 0)
candidate->state = RXRPC_CALL_SERVER_SECURING; candidate->state = RXRPC_CALL_SERVER_SECURING;
rcu_assign_pointer(candidate->socket, rx);
spin_lock(&conn->channel_lock); spin_lock(&conn->channel_lock);
...@@ -358,7 +361,7 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx, ...@@ -358,7 +361,7 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx,
read_unlock(&call->state_lock); read_unlock(&call->state_lock);
goto aborted_call; goto aborted_call;
default: default:
rxrpc_get_call(call); rxrpc_get_call(call, rxrpc_call_got);
read_unlock(&call->state_lock); read_unlock(&call->state_lock);
goto extant_call; goto extant_call;
} }
...@@ -396,7 +399,6 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx, ...@@ -396,7 +399,6 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx,
candidate = NULL; candidate = NULL;
conn->channels[chan].call_counter = call_id; conn->channels[chan].call_counter = call_id;
rcu_assign_pointer(conn->channels[chan].call, call); rcu_assign_pointer(conn->channels[chan].call, call);
sock_hold(&rx->sk);
rxrpc_get_connection(conn); rxrpc_get_connection(conn);
rxrpc_get_peer(call->peer); rxrpc_get_peer(call->peer);
spin_unlock(&conn->channel_lock); spin_unlock(&conn->channel_lock);
...@@ -437,6 +439,39 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx, ...@@ -437,6 +439,39 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx,
return ERR_PTR(-ECONNRESET); return ERR_PTR(-ECONNRESET);
} }
/*
* Queue a call's work processor, getting a ref to pass to the work queue.
*/
bool rxrpc_queue_call(struct rxrpc_call *call)
{
const void *here = __builtin_return_address(0);
int n = __atomic_add_unless(&call->usage, 1, 0);
int m = atomic_read(&call->skb_count);
if (n == 0)
return false;
if (rxrpc_queue_work(&call->processor))
trace_rxrpc_call(call, rxrpc_call_queued, n + 1, m, here, NULL);
else
rxrpc_put_call(call, rxrpc_call_put_noqueue);
return true;
}
/*
* Queue a call's work processor, passing the callers ref to the work queue.
*/
bool __rxrpc_queue_call(struct rxrpc_call *call)
{
const void *here = __builtin_return_address(0);
int n = atomic_read(&call->usage);
int m = atomic_read(&call->skb_count);
ASSERTCMP(n, >=, 1);
if (rxrpc_queue_work(&call->processor))
trace_rxrpc_call(call, rxrpc_call_queued_ref, n, m, here, NULL);
else
rxrpc_put_call(call, rxrpc_call_put_noqueue);
return true;
}
/* /*
* Note the re-emergence of a call. * Note the re-emergence of a call.
*/ */
...@@ -447,20 +482,20 @@ void rxrpc_see_call(struct rxrpc_call *call) ...@@ -447,20 +482,20 @@ void rxrpc_see_call(struct rxrpc_call *call)
int n = atomic_read(&call->usage); int n = atomic_read(&call->usage);
int m = atomic_read(&call->skb_count); int m = atomic_read(&call->skb_count);
trace_rxrpc_call(call, 2, n, m, here, 0); trace_rxrpc_call(call, rxrpc_call_seen, n, m, here, NULL);
} }
} }
/* /*
* Note the addition of a ref on a call. * Note the addition of a ref on a call.
*/ */
void rxrpc_get_call(struct rxrpc_call *call) void rxrpc_get_call(struct rxrpc_call *call, enum rxrpc_call_trace op)
{ {
const void *here = __builtin_return_address(0); const void *here = __builtin_return_address(0);
int n = atomic_inc_return(&call->usage); int n = atomic_inc_return(&call->usage);
int m = atomic_read(&call->skb_count); int m = atomic_read(&call->skb_count);
trace_rxrpc_call(call, 3, n, m, here, 0); trace_rxrpc_call(call, op, n, m, here, NULL);
} }
/* /*
...@@ -472,17 +507,14 @@ void rxrpc_get_call_for_skb(struct rxrpc_call *call, struct sk_buff *skb) ...@@ -472,17 +507,14 @@ void rxrpc_get_call_for_skb(struct rxrpc_call *call, struct sk_buff *skb)
int n = atomic_inc_return(&call->usage); int n = atomic_inc_return(&call->usage);
int m = atomic_inc_return(&call->skb_count); int m = atomic_inc_return(&call->skb_count);
trace_rxrpc_call(call, 4, n, m, here, skb); trace_rxrpc_call(call, rxrpc_call_got_skb, n, m, here, skb);
} }
/* /*
* detach a call from a socket and set up for release * detach a call from a socket and set up for release
*/ */
void rxrpc_release_call(struct rxrpc_call *call) void rxrpc_release_call(struct rxrpc_sock *rx, struct rxrpc_call *call)
{ {
struct rxrpc_connection *conn = call->conn;
struct rxrpc_sock *rx = call->socket;
_enter("{%d,%d,%d,%d}", _enter("{%d,%d,%d,%d}",
call->debug_id, atomic_read(&call->usage), call->debug_id, atomic_read(&call->usage),
atomic_read(&call->ackr_not_idle), atomic_read(&call->ackr_not_idle),
...@@ -498,11 +530,13 @@ void rxrpc_release_call(struct rxrpc_call *call) ...@@ -498,11 +530,13 @@ void rxrpc_release_call(struct rxrpc_call *call)
/* dissociate from the socket /* dissociate from the socket
* - the socket's ref on the call is passed to the death timer * - the socket's ref on the call is passed to the death timer
*/ */
_debug("RELEASE CALL %p (%d CONN %p)", call, call->debug_id, conn); _debug("RELEASE CALL %p (%d)", call, call->debug_id);
spin_lock(&conn->params.peer->lock); if (call->peer) {
hlist_del_init(&call->error_link); spin_lock(&call->peer->lock);
spin_unlock(&conn->params.peer->lock); hlist_del_init(&call->error_link);
spin_unlock(&call->peer->lock);
}
write_lock_bh(&rx->call_lock); write_lock_bh(&rx->call_lock);
if (!list_empty(&call->accept_link)) { if (!list_empty(&call->accept_link)) {
...@@ -515,20 +549,30 @@ void rxrpc_release_call(struct rxrpc_call *call) ...@@ -515,20 +549,30 @@ void rxrpc_release_call(struct rxrpc_call *call)
rb_erase(&call->sock_node, &rx->calls); rb_erase(&call->sock_node, &rx->calls);
memset(&call->sock_node, 0xdd, sizeof(call->sock_node)); memset(&call->sock_node, 0xdd, sizeof(call->sock_node));
clear_bit(RXRPC_CALL_HAS_USERID, &call->flags); clear_bit(RXRPC_CALL_HAS_USERID, &call->flags);
rxrpc_put_call(call, rxrpc_call_put_userid);
} }
write_unlock_bh(&rx->call_lock); write_unlock_bh(&rx->call_lock);
/* free up the channel for reuse */ /* free up the channel for reuse */
write_lock_bh(&call->state_lock); if (call->state == RXRPC_CALL_CLIENT_FINAL_ACK) {
clear_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events);
rxrpc_send_call_packet(call, RXRPC_PACKET_TYPE_ACK);
rxrpc_call_completed(call);
} else {
write_lock_bh(&call->state_lock);
if (call->state < RXRPC_CALL_COMPLETE) {
_debug("+++ ABORTING STATE %d +++\n", call->state);
__rxrpc_abort_call(call, RX_CALL_DEAD, ECONNRESET);
clear_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events);
rxrpc_send_call_packet(call, RXRPC_PACKET_TYPE_ABORT);
}
if (call->state < RXRPC_CALL_COMPLETE && write_unlock_bh(&call->state_lock);
call->state != RXRPC_CALL_CLIENT_FINAL_ACK) {
_debug("+++ ABORTING STATE %d +++\n", call->state);
__rxrpc_abort_call(call, RX_CALL_DEAD, ECONNRESET);
} }
write_unlock_bh(&call->state_lock);
rxrpc_disconnect_call(call); if (call->conn)
rxrpc_disconnect_call(call);
/* clean up the Rx queue */ /* clean up the Rx queue */
if (!skb_queue_empty(&call->rx_queue) || if (!skb_queue_empty(&call->rx_queue) ||
...@@ -552,52 +596,15 @@ void rxrpc_release_call(struct rxrpc_call *call) ...@@ -552,52 +596,15 @@ void rxrpc_release_call(struct rxrpc_call *call)
} }
spin_unlock_bh(&call->lock); spin_unlock_bh(&call->lock);
} }
rxrpc_purge_queue(&call->knlrecv_queue);
del_timer_sync(&call->resend_timer); del_timer_sync(&call->resend_timer);
del_timer_sync(&call->ack_timer); del_timer_sync(&call->ack_timer);
del_timer_sync(&call->lifetimer); del_timer_sync(&call->lifetimer);
call->deadspan.expires = jiffies + rxrpc_dead_call_expiry;
add_timer(&call->deadspan);
_leave(""); _leave("");
} }
/*
* handle a dead call being ready for reaping
*/
static void rxrpc_dead_call_expired(unsigned long _call)
{
struct rxrpc_call *call = (struct rxrpc_call *) _call;
_enter("{%d}", call->debug_id);
rxrpc_see_call(call);
write_lock_bh(&call->state_lock);
call->state = RXRPC_CALL_DEAD;
write_unlock_bh(&call->state_lock);
rxrpc_put_call(call);
}
/*
* mark a call as to be released, aborting it if it's still in progress
* - called with softirqs disabled
*/
static void rxrpc_mark_call_released(struct rxrpc_call *call)
{
bool sched = false;
rxrpc_see_call(call);
write_lock(&call->state_lock);
if (call->state < RXRPC_CALL_DEAD) {
sched = __rxrpc_abort_call(call, RX_CALL_DEAD, ECONNRESET);
if (!test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))
sched = true;
}
write_unlock(&call->state_lock);
if (sched)
rxrpc_queue_call(call);
}
/* /*
* release all the calls associated with a socket * release all the calls associated with a socket
*/ */
...@@ -612,17 +619,17 @@ void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx) ...@@ -612,17 +619,17 @@ void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx)
/* kill the not-yet-accepted incoming calls */ /* kill the not-yet-accepted incoming calls */
list_for_each_entry(call, &rx->secureq, accept_link) { list_for_each_entry(call, &rx->secureq, accept_link) {
rxrpc_mark_call_released(call); rxrpc_release_call(rx, call);
} }
list_for_each_entry(call, &rx->acceptq, accept_link) { list_for_each_entry(call, &rx->acceptq, accept_link) {
rxrpc_mark_call_released(call); rxrpc_release_call(rx, call);
} }
/* mark all the calls as no longer wanting incoming packets */ /* mark all the calls as no longer wanting incoming packets */
for (p = rb_first(&rx->calls); p; p = rb_next(p)) { for (p = rb_first(&rx->calls); p; p = rb_next(p)) {
call = rb_entry(p, struct rxrpc_call, sock_node); call = rb_entry(p, struct rxrpc_call, sock_node);
rxrpc_mark_call_released(call); rxrpc_release_call(rx, call);
} }
read_unlock_bh(&rx->call_lock); read_unlock_bh(&rx->call_lock);
...@@ -632,7 +639,7 @@ void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx) ...@@ -632,7 +639,7 @@ void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx)
/* /*
* release a call * release a call
*/ */
void rxrpc_put_call(struct rxrpc_call *call) void rxrpc_put_call(struct rxrpc_call *call, enum rxrpc_call_trace op)
{ {
const void *here = __builtin_return_address(0); const void *here = __builtin_return_address(0);
int n, m; int n, m;
...@@ -641,13 +648,12 @@ void rxrpc_put_call(struct rxrpc_call *call) ...@@ -641,13 +648,12 @@ void rxrpc_put_call(struct rxrpc_call *call)
n = atomic_dec_return(&call->usage); n = atomic_dec_return(&call->usage);
m = atomic_read(&call->skb_count); m = atomic_read(&call->skb_count);
trace_rxrpc_call(call, 5, n, m, here, NULL); trace_rxrpc_call(call, op, n, m, here, NULL);
ASSERTCMP(n, >=, 0); ASSERTCMP(n, >=, 0);
if (n == 0) { if (n == 0) {
_debug("call %d dead", call->debug_id); _debug("call %d dead", call->debug_id);
WARN_ON(m != 0); WARN_ON(m != 0);
ASSERTCMP(call->state, ==, RXRPC_CALL_DEAD); rxrpc_cleanup_call(call);
rxrpc_queue_work(&call->destroyer);
} }
} }
...@@ -661,13 +667,12 @@ void rxrpc_put_call_for_skb(struct rxrpc_call *call, struct sk_buff *skb) ...@@ -661,13 +667,12 @@ void rxrpc_put_call_for_skb(struct rxrpc_call *call, struct sk_buff *skb)
n = atomic_dec_return(&call->usage); n = atomic_dec_return(&call->usage);
m = atomic_dec_return(&call->skb_count); m = atomic_dec_return(&call->skb_count);
trace_rxrpc_call(call, 6, n, m, here, skb); trace_rxrpc_call(call, rxrpc_call_put_skb, n, m, here, skb);
ASSERTCMP(n, >=, 0); ASSERTCMP(n, >=, 0);
if (n == 0) { if (n == 0) {
_debug("call %d dead", call->debug_id); _debug("call %d dead", call->debug_id);
WARN_ON(m != 0); WARN_ON(m != 0);
ASSERTCMP(call->state, ==, RXRPC_CALL_DEAD); rxrpc_cleanup_call(call);
rxrpc_queue_work(&call->destroyer);
} }
} }
...@@ -691,23 +696,19 @@ static void rxrpc_cleanup_call(struct rxrpc_call *call) ...@@ -691,23 +696,19 @@ static void rxrpc_cleanup_call(struct rxrpc_call *call)
{ {
_net("DESTROY CALL %d", call->debug_id); _net("DESTROY CALL %d", call->debug_id);
ASSERT(call->socket); write_lock_bh(&rxrpc_call_lock);
list_del_init(&call->link);
write_unlock_bh(&rxrpc_call_lock);
memset(&call->sock_node, 0xcd, sizeof(call->sock_node)); memset(&call->sock_node, 0xcd, sizeof(call->sock_node));
del_timer_sync(&call->lifetimer); del_timer_sync(&call->lifetimer);
del_timer_sync(&call->deadspan);
del_timer_sync(&call->ack_timer); del_timer_sync(&call->ack_timer);
del_timer_sync(&call->resend_timer); del_timer_sync(&call->resend_timer);
ASSERTCMP(call->state, ==, RXRPC_CALL_COMPLETE);
ASSERT(test_bit(RXRPC_CALL_RELEASED, &call->flags)); ASSERT(test_bit(RXRPC_CALL_RELEASED, &call->flags));
ASSERTCMP(call->events, ==, 0); ASSERT(!work_pending(&call->processor));
if (work_pending(&call->processor)) {
_debug("defer destroy");
rxrpc_queue_work(&call->destroyer);
return;
}
ASSERTCMP(call->conn, ==, NULL); ASSERTCMP(call->conn, ==, NULL);
if (call->acks_window) { if (call->acks_window) {
...@@ -736,40 +737,21 @@ static void rxrpc_cleanup_call(struct rxrpc_call *call) ...@@ -736,40 +737,21 @@ static void rxrpc_cleanup_call(struct rxrpc_call *call)
rxrpc_purge_queue(&call->rx_queue); rxrpc_purge_queue(&call->rx_queue);
ASSERT(skb_queue_empty(&call->rx_oos_queue)); ASSERT(skb_queue_empty(&call->rx_oos_queue));
rxrpc_purge_queue(&call->knlrecv_queue); rxrpc_purge_queue(&call->knlrecv_queue);
sock_put(&call->socket->sk);
call_rcu(&call->rcu, rxrpc_rcu_destroy_call); call_rcu(&call->rcu, rxrpc_rcu_destroy_call);
} }
/* /*
* destroy a call * Make sure that all calls are gone.
*/
static void rxrpc_destroy_call(struct work_struct *work)
{
struct rxrpc_call *call =
container_of(work, struct rxrpc_call, destroyer);
_enter("%p{%d,%x,%p}",
call, atomic_read(&call->usage), call->cid, call->conn);
ASSERTCMP(call->state, ==, RXRPC_CALL_DEAD);
write_lock_bh(&rxrpc_call_lock);
list_del_init(&call->link);
write_unlock_bh(&rxrpc_call_lock);
rxrpc_cleanup_call(call);
_leave("");
}
/*
* preemptively destroy all the call records from a transport endpoint rather
* than waiting for them to time out
*/ */
void __exit rxrpc_destroy_all_calls(void) void __exit rxrpc_destroy_all_calls(void)
{ {
struct rxrpc_call *call; struct rxrpc_call *call;
_enter(""); _enter("");
if (list_empty(&rxrpc_calls))
return;
write_lock_bh(&rxrpc_call_lock); write_lock_bh(&rxrpc_call_lock);
while (!list_empty(&rxrpc_calls)) { while (!list_empty(&rxrpc_calls)) {
...@@ -779,28 +761,15 @@ void __exit rxrpc_destroy_all_calls(void) ...@@ -779,28 +761,15 @@ void __exit rxrpc_destroy_all_calls(void)
rxrpc_see_call(call); rxrpc_see_call(call);
list_del_init(&call->link); list_del_init(&call->link);
switch (atomic_read(&call->usage)) { pr_err("Call %p still in use (%d,%d,%s,%lx,%lx)!\n",
case 0: call, atomic_read(&call->usage),
ASSERTCMP(call->state, ==, RXRPC_CALL_DEAD); atomic_read(&call->ackr_not_idle),
break; rxrpc_call_states[call->state],
case 1: call->flags, call->events);
if (del_timer_sync(&call->deadspan) != 0 && if (!skb_queue_empty(&call->rx_queue))
call->state != RXRPC_CALL_DEAD) pr_err("Rx queue occupied\n");
rxrpc_dead_call_expired((unsigned long) call); if (!skb_queue_empty(&call->rx_oos_queue))
if (call->state != RXRPC_CALL_DEAD) pr_err("OOS queue occupied\n");
break;
default:
pr_err("Call %p still in use (%d,%d,%s,%lx,%lx)!\n",
call, atomic_read(&call->usage),
atomic_read(&call->ackr_not_idle),
rxrpc_call_states[call->state],
call->flags, call->events);
if (!skb_queue_empty(&call->rx_queue))
pr_err("Rx queue occupied\n");
if (!skb_queue_empty(&call->rx_oos_queue))
pr_err("OOS queue occupied\n");
break;
}
write_unlock_bh(&rxrpc_call_lock); write_unlock_bh(&rxrpc_call_lock);
cond_resched(); cond_resched();
......
...@@ -348,6 +348,7 @@ static int rxrpc_get_client_conn(struct rxrpc_call *call, ...@@ -348,6 +348,7 @@ static int rxrpc_get_client_conn(struct rxrpc_call *call,
if (cp->exclusive) { if (cp->exclusive) {
call->conn = candidate; call->conn = candidate;
call->security_ix = candidate->security_ix;
_leave(" = 0 [exclusive %d]", candidate->debug_id); _leave(" = 0 [exclusive %d]", candidate->debug_id);
return 0; return 0;
} }
...@@ -395,6 +396,7 @@ static int rxrpc_get_client_conn(struct rxrpc_call *call, ...@@ -395,6 +396,7 @@ static int rxrpc_get_client_conn(struct rxrpc_call *call,
candidate_published: candidate_published:
set_bit(RXRPC_CONN_IN_CLIENT_CONNS, &candidate->flags); set_bit(RXRPC_CONN_IN_CLIENT_CONNS, &candidate->flags);
call->conn = candidate; call->conn = candidate;
call->security_ix = candidate->security_ix;
spin_unlock(&local->client_conns_lock); spin_unlock(&local->client_conns_lock);
_leave(" = 0 [new %d]", candidate->debug_id); _leave(" = 0 [new %d]", candidate->debug_id);
return 0; return 0;
...@@ -412,6 +414,7 @@ static int rxrpc_get_client_conn(struct rxrpc_call *call, ...@@ -412,6 +414,7 @@ static int rxrpc_get_client_conn(struct rxrpc_call *call,
spin_lock(&conn->channel_lock); spin_lock(&conn->channel_lock);
call->conn = conn; call->conn = conn;
call->security_ix = conn->security_ix;
list_add(&call->chan_wait_link, &conn->waiting_calls); list_add(&call->chan_wait_link, &conn->waiting_calls);
spin_unlock(&conn->channel_lock); spin_unlock(&conn->channel_lock);
_leave(" = 0 [extant %d]", conn->debug_id); _leave(" = 0 [extant %d]", conn->debug_id);
......
...@@ -39,7 +39,7 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb, ...@@ -39,7 +39,7 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb,
bool force, bool terminal) bool force, bool terminal)
{ {
struct rxrpc_skb_priv *sp; struct rxrpc_skb_priv *sp;
struct rxrpc_sock *rx = call->socket; struct rxrpc_sock *rx;
struct sock *sk; struct sock *sk;
int ret; int ret;
...@@ -59,7 +59,15 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb, ...@@ -59,7 +59,15 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb,
return 0; return 0;
} }
/* The socket may go away under us */
ret = 0;
rcu_read_lock();
rx = rcu_dereference(call->socket);
if (!rx)
goto out;
sk = &rx->sk; sk = &rx->sk;
if (sock_flag(sk, SOCK_DEAD))
goto out;
if (!force) { if (!force) {
/* cast skb->rcvbuf to unsigned... It's pointless, but /* cast skb->rcvbuf to unsigned... It's pointless, but
...@@ -78,7 +86,7 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb, ...@@ -78,7 +86,7 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb,
spin_lock_bh(&sk->sk_receive_queue.lock); spin_lock_bh(&sk->sk_receive_queue.lock);
if (!test_bit(RXRPC_CALL_TERMINAL_MSG, &call->flags) && if (!test_bit(RXRPC_CALL_TERMINAL_MSG, &call->flags) &&
!test_bit(RXRPC_CALL_RELEASED, &call->flags) && !test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
call->socket->sk.sk_state != RXRPC_CLOSE) { sk->sk_state != RXRPC_CLOSE) {
skb->destructor = rxrpc_packet_destructor; skb->destructor = rxrpc_packet_destructor;
skb->dev = NULL; skb->dev = NULL;
skb->sk = sk; skb->sk = sk;
...@@ -104,8 +112,7 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb, ...@@ -104,8 +112,7 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb,
__skb_queue_tail(&sk->sk_receive_queue, skb); __skb_queue_tail(&sk->sk_receive_queue, skb);
spin_unlock_bh(&sk->sk_receive_queue.lock); spin_unlock_bh(&sk->sk_receive_queue.lock);
if (!sock_flag(sk, SOCK_DEAD)) sk->sk_data_ready(sk);
sk->sk_data_ready(sk);
} }
skb = NULL; skb = NULL;
} else { } else {
...@@ -115,6 +122,7 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb, ...@@ -115,6 +122,7 @@ int rxrpc_queue_rcv_skb(struct rxrpc_call *call, struct sk_buff *skb,
out: out:
rxrpc_free_skb(skb); rxrpc_free_skb(skb);
rcu_read_unlock();
_leave(" = %d", ret); _leave(" = %d", ret);
return ret; return ret;
...@@ -198,7 +206,7 @@ static int rxrpc_fast_process_data(struct rxrpc_call *call, ...@@ -198,7 +206,7 @@ static int rxrpc_fast_process_data(struct rxrpc_call *call,
/* if the packet need security things doing to it, then it goes down /* if the packet need security things doing to it, then it goes down
* the slow path */ * the slow path */
if (call->conn->security_ix) if (call->security_ix)
goto enqueue_packet; goto enqueue_packet;
sp->call = call; sp->call = call;
...@@ -266,7 +274,7 @@ static int rxrpc_fast_process_data(struct rxrpc_call *call, ...@@ -266,7 +274,7 @@ static int rxrpc_fast_process_data(struct rxrpc_call *call,
skb_queue_tail(&call->rx_queue, skb); skb_queue_tail(&call->rx_queue, skb);
atomic_inc(&call->ackr_not_idle); atomic_inc(&call->ackr_not_idle);
read_lock(&call->state_lock); read_lock(&call->state_lock);
if (call->state < RXRPC_CALL_DEAD) if (call->state < RXRPC_CALL_COMPLETE)
rxrpc_queue_call(call); rxrpc_queue_call(call);
read_unlock(&call->state_lock); read_unlock(&call->state_lock);
_leave(" = 0 [queued]"); _leave(" = 0 [queued]");
...@@ -357,7 +365,7 @@ void rxrpc_fast_process_packet(struct rxrpc_call *call, struct sk_buff *skb) ...@@ -357,7 +365,7 @@ void rxrpc_fast_process_packet(struct rxrpc_call *call, struct sk_buff *skb)
case RXRPC_PACKET_TYPE_BUSY: case RXRPC_PACKET_TYPE_BUSY:
_proto("Rx BUSY %%%u", sp->hdr.serial); _proto("Rx BUSY %%%u", sp->hdr.serial);
if (rxrpc_conn_is_service(call->conn)) if (rxrpc_is_service_call(call))
goto protocol_error; goto protocol_error;
write_lock_bh(&call->state_lock); write_lock_bh(&call->state_lock);
...@@ -408,7 +416,7 @@ void rxrpc_fast_process_packet(struct rxrpc_call *call, struct sk_buff *skb) ...@@ -408,7 +416,7 @@ void rxrpc_fast_process_packet(struct rxrpc_call *call, struct sk_buff *skb)
case RXRPC_PACKET_TYPE_ACK: case RXRPC_PACKET_TYPE_ACK:
/* ACK processing is done in process context */ /* ACK processing is done in process context */
read_lock_bh(&call->state_lock); read_lock_bh(&call->state_lock);
if (call->state < RXRPC_CALL_DEAD) { if (call->state < RXRPC_CALL_COMPLETE) {
skb_queue_tail(&call->rx_queue, skb); skb_queue_tail(&call->rx_queue, skb);
rxrpc_queue_call(call); rxrpc_queue_call(call);
skb = NULL; skb = NULL;
...@@ -497,7 +505,8 @@ static void rxrpc_process_jumbo_packet(struct rxrpc_call *call, ...@@ -497,7 +505,8 @@ static void rxrpc_process_jumbo_packet(struct rxrpc_call *call,
* post an incoming packet to the appropriate call/socket to deal with * post an incoming packet to the appropriate call/socket to deal with
* - must get rid of the sk_buff, either by freeing it or by queuing it * - must get rid of the sk_buff, either by freeing it or by queuing it
*/ */
static void rxrpc_post_packet_to_call(struct rxrpc_call *call, static void rxrpc_post_packet_to_call(struct rxrpc_connection *conn,
struct rxrpc_call *call,
struct sk_buff *skb) struct sk_buff *skb)
{ {
struct rxrpc_skb_priv *sp; struct rxrpc_skb_priv *sp;
...@@ -510,9 +519,6 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call, ...@@ -510,9 +519,6 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call,
read_lock(&call->state_lock); read_lock(&call->state_lock);
switch (call->state) { switch (call->state) {
case RXRPC_CALL_DEAD:
goto dead_call;
case RXRPC_CALL_COMPLETE: case RXRPC_CALL_COMPLETE:
switch (call->completion) { switch (call->completion) {
case RXRPC_CALL_LOCALLY_ABORTED: case RXRPC_CALL_LOCALLY_ABORTED:
...@@ -524,7 +530,7 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call, ...@@ -524,7 +530,7 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call,
default: default:
goto dead_call; goto dead_call;
case RXRPC_CALL_SUCCEEDED: case RXRPC_CALL_SUCCEEDED:
if (rxrpc_conn_is_service(call->conn)) if (rxrpc_is_service_call(call))
goto dead_call; goto dead_call;
goto resend_final_ack; goto resend_final_ack;
} }
...@@ -537,7 +543,6 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call, ...@@ -537,7 +543,6 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call,
} }
read_unlock(&call->state_lock); read_unlock(&call->state_lock);
rxrpc_get_call(call);
if (sp->hdr.type == RXRPC_PACKET_TYPE_DATA && if (sp->hdr.type == RXRPC_PACKET_TYPE_DATA &&
sp->hdr.flags & RXRPC_JUMBO_PACKET) sp->hdr.flags & RXRPC_JUMBO_PACKET)
...@@ -545,12 +550,10 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call, ...@@ -545,12 +550,10 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call,
else else
rxrpc_fast_process_packet(call, skb); rxrpc_fast_process_packet(call, skb);
rxrpc_put_call(call);
goto done; goto done;
resend_final_ack: resend_final_ack:
_debug("final ack again"); _debug("final ack again");
rxrpc_get_call(call);
set_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events); set_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events);
rxrpc_queue_call(call); rxrpc_queue_call(call);
goto free_unlock; goto free_unlock;
...@@ -558,7 +561,7 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call, ...@@ -558,7 +561,7 @@ static void rxrpc_post_packet_to_call(struct rxrpc_call *call,
dead_call: dead_call:
if (sp->hdr.type != RXRPC_PACKET_TYPE_ABORT) { if (sp->hdr.type != RXRPC_PACKET_TYPE_ABORT) {
skb->priority = RX_CALL_DEAD; skb->priority = RX_CALL_DEAD;
rxrpc_reject_packet(call->conn->params.local, skb); rxrpc_reject_packet(conn->params.local, skb);
goto unlock; goto unlock;
} }
free_unlock: free_unlock:
...@@ -754,7 +757,7 @@ void rxrpc_data_ready(struct sock *sk) ...@@ -754,7 +757,7 @@ void rxrpc_data_ready(struct sock *sk)
goto cant_route_call; goto cant_route_call;
rxrpc_see_call(call); rxrpc_see_call(call);
rxrpc_post_packet_to_call(call, skb); rxrpc_post_packet_to_call(conn, call, skb);
goto out_unlock; goto out_unlock;
} }
......
...@@ -19,6 +19,151 @@ ...@@ -19,6 +19,151 @@
#include <net/af_rxrpc.h> #include <net/af_rxrpc.h>
#include "ar-internal.h" #include "ar-internal.h"
struct rxrpc_pkt_buffer {
struct rxrpc_wire_header whdr;
union {
struct {
struct rxrpc_ackpacket ack;
u8 acks[255];
u8 pad[3];
};
__be32 abort_code;
};
struct rxrpc_ackinfo ackinfo;
};
/*
* Fill out an ACK packet.
*/
static size_t rxrpc_fill_out_ack(struct rxrpc_call *call,
struct rxrpc_pkt_buffer *pkt)
{
u32 mtu, jmax;
u8 *ackp = pkt->acks;
pkt->ack.bufferSpace = htons(8);
pkt->ack.maxSkew = htons(0);
pkt->ack.firstPacket = htonl(call->rx_data_eaten + 1);
pkt->ack.previousPacket = htonl(call->ackr_prev_seq);
pkt->ack.serial = htonl(call->ackr_serial);
pkt->ack.reason = RXRPC_ACK_IDLE;
pkt->ack.nAcks = 0;
mtu = call->peer->if_mtu;
mtu -= call->peer->hdrsize;
jmax = rxrpc_rx_jumbo_max;
pkt->ackinfo.rxMTU = htonl(rxrpc_rx_mtu);
pkt->ackinfo.maxMTU = htonl(mtu);
pkt->ackinfo.rwind = htonl(rxrpc_rx_window_size);
pkt->ackinfo.jumbo_max = htonl(jmax);
*ackp++ = 0;
*ackp++ = 0;
*ackp++ = 0;
return 3;
}
/*
* Send a final ACK or ABORT call packet.
*/
int rxrpc_send_call_packet(struct rxrpc_call *call, u8 type)
{
struct rxrpc_connection *conn = NULL;
struct rxrpc_pkt_buffer *pkt;
struct msghdr msg;
struct kvec iov[2];
rxrpc_serial_t serial;
size_t len, n;
int ioc, ret;
u32 abort_code;
_enter("%u,%s", call->debug_id, rxrpc_pkts[type]);
spin_lock_bh(&call->lock);
if (call->conn)
conn = rxrpc_get_connection_maybe(call->conn);
spin_unlock_bh(&call->lock);
if (!conn)
return -ECONNRESET;
pkt = kzalloc(sizeof(*pkt), GFP_KERNEL);
if (!pkt) {
rxrpc_put_connection(conn);
return -ENOMEM;
}
serial = atomic_inc_return(&conn->serial);
msg.msg_name = &call->peer->srx.transport;
msg.msg_namelen = call->peer->srx.transport_len;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flags = 0;
pkt->whdr.epoch = htonl(conn->proto.epoch);
pkt->whdr.cid = htonl(call->cid);
pkt->whdr.callNumber = htonl(call->call_id);
pkt->whdr.seq = 0;
pkt->whdr.serial = htonl(serial);
pkt->whdr.type = type;
pkt->whdr.flags = conn->out_clientflag;
pkt->whdr.userStatus = 0;
pkt->whdr.securityIndex = call->security_ix;
pkt->whdr._rsvd = 0;
pkt->whdr.serviceId = htons(call->service_id);
iov[0].iov_base = pkt;
iov[0].iov_len = sizeof(pkt->whdr);
len = sizeof(pkt->whdr);
switch (type) {
case RXRPC_PACKET_TYPE_ACK:
spin_lock_bh(&call->lock);
n = rxrpc_fill_out_ack(call, pkt);
call->ackr_reason = 0;
spin_unlock_bh(&call->lock);
_proto("Tx ACK %%%u { m=%hu f=#%u p=#%u s=%%%u r=%s n=%u }",
serial,
ntohs(pkt->ack.maxSkew),
ntohl(pkt->ack.firstPacket),
ntohl(pkt->ack.previousPacket),
ntohl(pkt->ack.serial),
rxrpc_acks(pkt->ack.reason),
pkt->ack.nAcks);
iov[0].iov_len += sizeof(pkt->ack) + n;
iov[1].iov_base = &pkt->ackinfo;
iov[1].iov_len = sizeof(pkt->ackinfo);
len += sizeof(pkt->ack) + n + sizeof(pkt->ackinfo);
ioc = 2;
break;
case RXRPC_PACKET_TYPE_ABORT:
abort_code = call->abort_code;
pkt->abort_code = htonl(abort_code);
_proto("Tx ABORT %%%u { %d }", serial, abort_code);
iov[0].iov_len += sizeof(pkt->abort_code);
len += sizeof(pkt->abort_code);
ioc = 1;
break;
default:
BUG();
ret = -ENOANO;
goto out;
}
ret = kernel_sendmsg(conn->params.local->socket,
&msg, iov, ioc, len);
out:
rxrpc_put_connection(conn);
kfree(pkt);
return ret;
}
/* /*
* send a packet through the transport endpoint * send a packet through the transport endpoint
*/ */
......
...@@ -29,6 +29,7 @@ static const char *const rxrpc_conn_states[RXRPC_CONN__NR_STATES] = { ...@@ -29,6 +29,7 @@ static const char *const rxrpc_conn_states[RXRPC_CONN__NR_STATES] = {
*/ */
static void *rxrpc_call_seq_start(struct seq_file *seq, loff_t *_pos) static void *rxrpc_call_seq_start(struct seq_file *seq, loff_t *_pos)
{ {
rcu_read_lock();
read_lock(&rxrpc_call_lock); read_lock(&rxrpc_call_lock);
return seq_list_start_head(&rxrpc_calls, *_pos); return seq_list_start_head(&rxrpc_calls, *_pos);
} }
...@@ -41,6 +42,7 @@ static void *rxrpc_call_seq_next(struct seq_file *seq, void *v, loff_t *pos) ...@@ -41,6 +42,7 @@ static void *rxrpc_call_seq_next(struct seq_file *seq, void *v, loff_t *pos)
static void rxrpc_call_seq_stop(struct seq_file *seq, void *v) static void rxrpc_call_seq_stop(struct seq_file *seq, void *v)
{ {
read_unlock(&rxrpc_call_lock); read_unlock(&rxrpc_call_lock);
rcu_read_unlock();
} }
static int rxrpc_call_seq_show(struct seq_file *seq, void *v) static int rxrpc_call_seq_show(struct seq_file *seq, void *v)
...@@ -61,7 +63,7 @@ static int rxrpc_call_seq_show(struct seq_file *seq, void *v) ...@@ -61,7 +63,7 @@ static int rxrpc_call_seq_show(struct seq_file *seq, void *v)
call = list_entry(v, struct rxrpc_call, link); call = list_entry(v, struct rxrpc_call, link);
rx = READ_ONCE(call->socket); rx = rcu_dereference(call->socket);
if (rx) { if (rx) {
local = READ_ONCE(rx->local); local = READ_ONCE(rx->local);
if (local) if (local)
......
...@@ -18,28 +18,6 @@ ...@@ -18,28 +18,6 @@
#include <net/af_rxrpc.h> #include <net/af_rxrpc.h>
#include "ar-internal.h" #include "ar-internal.h"
/*
* removal a call's user ID from the socket tree to make the user ID available
* again and so that it won't be seen again in association with that call
*/
void rxrpc_remove_user_ID(struct rxrpc_sock *rx, struct rxrpc_call *call)
{
_debug("RELEASE CALL %d", call->debug_id);
if (test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
write_lock_bh(&rx->call_lock);
rb_erase(&call->sock_node, &call->socket->calls);
clear_bit(RXRPC_CALL_HAS_USERID, &call->flags);
write_unlock_bh(&rx->call_lock);
}
read_lock_bh(&call->state_lock);
if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
!test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))
rxrpc_queue_call(call);
read_unlock_bh(&call->state_lock);
}
/* /*
* receive a message from an RxRPC socket * receive a message from an RxRPC socket
* - we need to be careful about two or more threads calling recvmsg * - we need to be careful about two or more threads calling recvmsg
...@@ -79,7 +57,8 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, ...@@ -79,7 +57,8 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
if (rx->sk.sk_state != RXRPC_SERVER_LISTENING) { if (rx->sk.sk_state != RXRPC_SERVER_LISTENING) {
release_sock(&rx->sk); release_sock(&rx->sk);
if (continue_call) if (continue_call)
rxrpc_put_call(continue_call); rxrpc_put_call(continue_call,
rxrpc_call_put);
return -ENODATA; return -ENODATA;
} }
} }
...@@ -137,13 +116,13 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, ...@@ -137,13 +116,13 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
if (call != continue_call || if (call != continue_call ||
skb->mark != RXRPC_SKB_MARK_DATA) { skb->mark != RXRPC_SKB_MARK_DATA) {
release_sock(&rx->sk); release_sock(&rx->sk);
rxrpc_put_call(continue_call); rxrpc_put_call(continue_call, rxrpc_call_put);
_leave(" = %d [noncont]", copied); _leave(" = %d [noncont]", copied);
return copied; return copied;
} }
} }
rxrpc_get_call(call); rxrpc_get_call(call, rxrpc_call_got);
/* copy the peer address and timestamp */ /* copy the peer address and timestamp */
if (!continue_call) { if (!continue_call) {
...@@ -233,7 +212,7 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, ...@@ -233,7 +212,7 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
if (!continue_call) if (!continue_call)
continue_call = sp->call; continue_call = sp->call;
else else
rxrpc_put_call(call); rxrpc_put_call(call, rxrpc_call_put);
call = NULL; call = NULL;
if (flags & MSG_PEEK) { if (flags & MSG_PEEK) {
...@@ -255,9 +234,9 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, ...@@ -255,9 +234,9 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
out: out:
release_sock(&rx->sk); release_sock(&rx->sk);
if (call) if (call)
rxrpc_put_call(call); rxrpc_put_call(call, rxrpc_call_put);
if (continue_call) if (continue_call)
rxrpc_put_call(continue_call); rxrpc_put_call(continue_call, rxrpc_call_put);
_leave(" = %d [data]", copied); _leave(" = %d [data]", copied);
return copied; return copied;
...@@ -337,22 +316,22 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, ...@@ -337,22 +316,22 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
if (skb_dequeue(&rx->sk.sk_receive_queue) != skb) if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
BUG(); BUG();
rxrpc_free_skb(skb); rxrpc_free_skb(skb);
rxrpc_remove_user_ID(rx, call); rxrpc_release_call(rx, call);
} }
release_sock(&rx->sk); release_sock(&rx->sk);
rxrpc_put_call(call); rxrpc_put_call(call, rxrpc_call_put);
if (continue_call) if (continue_call)
rxrpc_put_call(continue_call); rxrpc_put_call(continue_call, rxrpc_call_put);
_leave(" = %d", ret); _leave(" = %d", ret);
return ret; return ret;
copy_error: copy_error:
_debug("copy error"); _debug("copy error");
release_sock(&rx->sk); release_sock(&rx->sk);
rxrpc_put_call(call); rxrpc_put_call(call, rxrpc_call_put);
if (continue_call) if (continue_call)
rxrpc_put_call(continue_call); rxrpc_put_call(continue_call, rxrpc_call_put);
_leave(" = %d", ret); _leave(" = %d", ret);
return ret; return ret;
...@@ -361,7 +340,7 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, ...@@ -361,7 +340,7 @@ int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
wait_error: wait_error:
finish_wait(sk_sleep(&rx->sk), &wait); finish_wait(sk_sleep(&rx->sk), &wait);
if (continue_call) if (continue_call)
rxrpc_put_call(continue_call); rxrpc_put_call(continue_call, rxrpc_call_put);
if (copied) if (copied)
copied = ret; copied = ret;
_leave(" = %d [waitfail %d]", copied, ret); _leave(" = %d [waitfail %d]", copied, ret);
......
...@@ -322,7 +322,7 @@ static int rxrpc_send_data(struct rxrpc_sock *rx, ...@@ -322,7 +322,7 @@ static int rxrpc_send_data(struct rxrpc_sock *rx,
sp->hdr.serial = atomic_inc_return(&conn->serial); sp->hdr.serial = atomic_inc_return(&conn->serial);
sp->hdr.type = RXRPC_PACKET_TYPE_DATA; sp->hdr.type = RXRPC_PACKET_TYPE_DATA;
sp->hdr.userStatus = 0; sp->hdr.userStatus = 0;
sp->hdr.securityIndex = conn->security_ix; sp->hdr.securityIndex = call->security_ix;
sp->hdr._rsvd = 0; sp->hdr._rsvd = 0;
sp->hdr.serviceId = call->service_id; sp->hdr.serviceId = call->service_id;
...@@ -534,7 +534,7 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len) ...@@ -534,7 +534,7 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len)
call = rxrpc_accept_call(rx, user_call_ID, NULL); call = rxrpc_accept_call(rx, user_call_ID, NULL);
if (IS_ERR(call)) if (IS_ERR(call))
return PTR_ERR(call); return PTR_ERR(call);
rxrpc_put_call(call); rxrpc_put_call(call, rxrpc_call_put);
return 0; return 0;
} }
...@@ -573,7 +573,7 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len) ...@@ -573,7 +573,7 @@ int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len)
ret = rxrpc_send_data(rx, call, msg, len); ret = rxrpc_send_data(rx, call, msg, len);
} }
rxrpc_put_call(call); rxrpc_put_call(call, rxrpc_call_put);
_leave(" = %d", ret); _leave(" = %d", ret);
return ret; return ret;
} }
......
...@@ -33,9 +33,6 @@ static void rxrpc_request_final_ACK(struct rxrpc_call *call) ...@@ -33,9 +33,6 @@ static void rxrpc_request_final_ACK(struct rxrpc_call *call)
call->state = RXRPC_CALL_CLIENT_FINAL_ACK; call->state = RXRPC_CALL_CLIENT_FINAL_ACK;
_debug("request final ACK"); _debug("request final ACK");
/* get an extra ref on the call for the final-ACK generator to
* release */
rxrpc_get_call(call);
set_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events); set_bit(RXRPC_CALL_EV_ACK_FINAL, &call->events);
if (try_to_del_timer_sync(&call->ack_timer) >= 0) if (try_to_del_timer_sync(&call->ack_timer) >= 0)
rxrpc_queue_call(call); rxrpc_queue_call(call);
...@@ -148,19 +145,6 @@ void rxrpc_packet_destructor(struct sk_buff *skb) ...@@ -148,19 +145,6 @@ void rxrpc_packet_destructor(struct sk_buff *skb)
_leave(""); _leave("");
} }
/**
* rxrpc_kernel_free_skb - Free an RxRPC socket buffer
* @skb: The socket buffer to be freed
*
* Let RxRPC free its own socket buffer, permitting it to maintain debug
* accounting.
*/
void rxrpc_kernel_free_skb(struct sk_buff *skb)
{
rxrpc_free_skb(skb);
}
EXPORT_SYMBOL(rxrpc_kernel_free_skb);
/* /*
* Note the existence of a new-to-us socket buffer (allocated or dequeued). * Note the existence of a new-to-us socket buffer (allocated or dequeued).
*/ */
......
...@@ -88,14 +88,6 @@ static struct ctl_table rxrpc_sysctl_table[] = { ...@@ -88,14 +88,6 @@ static struct ctl_table rxrpc_sysctl_table[] = {
.proc_handler = proc_dointvec_jiffies, .proc_handler = proc_dointvec_jiffies,
.extra1 = (void *)&one, .extra1 = (void *)&one,
}, },
{
.procname = "dead_call_expiry",
.data = &rxrpc_dead_call_expiry,
.maxlen = sizeof(unsigned int),
.mode = 0644,
.proc_handler = proc_dointvec_jiffies,
.extra1 = (void *)&one,
},
/* Non-time values */ /* Non-time values */
{ {
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment