Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4611da30 authored by Marc Dionne's avatar Marc Dionne Committed by David S. Miller
Browse files

rxrpc: Make rxrpc_kernel_check_life() indicate if call completed 



Make rxrpc_kernel_check_life() pass back the life counter through the
argument list and return true if the call has not yet completed.

Suggested-by: default avatarMarc Dionne <marc.dionne@auristor.com>
Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 56d282d9

Documentation/networking/rxrpc.txt

+9 −7
Original line number Diff line number Diff line
@@ -1009,16 +1009,18 @@ The kernel interface functions are as follows: 


 (*) Check call still alive.



	u32 rxrpc_kernel_check_life(struct socket *sock,

				    struct rxrpc_call *call);

	bool rxrpc_kernel_check_life(struct socket *sock,

				     struct rxrpc_call *call,

				     u32 *_life);

	void rxrpc_kernel_probe_life(struct socket *sock,

				     struct rxrpc_call *call);



     The first function returns a number that is updated when ACKs are received

     from the peer (notably including PING RESPONSE ACKs which we can elicit by

     sending PING ACKs to see if the call still exists on the server).  The

     caller should compare the numbers of two calls to see if the call is still

     alive after waiting for a suitable interval.

     The first function passes back in *_life a number that is updated when

     ACKs are received from the peer (notably including PING RESPONSE ACKs

     which we can elicit by sending PING ACKs to see if the call still exists

     on the server).  The caller should compare the numbers of two calls to see

     if the call is still alive after waiting for a suitable interval.  It also

     returns true as long as the call hasn't yet reached the completed state.



     This allows the caller to work out if the server is still contactable and

     if the call is still alive on the server while waiting for the server to

fs/afs/rxrpc.c

+2 −2
Original line number Diff line number Diff line
@@ -621,7 +621,7 @@ static long afs_wait_for_call_to_complete(struct afs_call *call, 
		rtt2 = 2;



	timeout = rtt2;

	last_life = rxrpc_kernel_check_life(call->net->socket, call->rxcall);

	rxrpc_kernel_check_life(call->net->socket, call->rxcall, &last_life);



	add_wait_queue(&call->waitq, &myself);

	for (;;) {
@@ -639,7 +639,7 @@ static long afs_wait_for_call_to_complete(struct afs_call *call, 
		if (afs_check_call_state(call, AFS_CALL_COMPLETE))

			break;



		life = rxrpc_kernel_check_life(call->net->socket, call->rxcall);

		rxrpc_kernel_check_life(call->net->socket, call->rxcall, &life);

		if (timeout == 0 &&

		    life == last_life && signal_pending(current)) {

			if (stalled)

include/net/af_rxrpc.h

+3 −1
Original line number Diff line number Diff line
@@ -61,10 +61,12 @@ int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t, 
			       rxrpc_user_attach_call_t, unsigned long, gfp_t,

			       unsigned int);

void rxrpc_kernel_set_tx_length(struct socket *, struct rxrpc_call *, s64);

u32 rxrpc_kernel_check_life(const struct socket *, const struct rxrpc_call *);

bool rxrpc_kernel_check_life(const struct socket *, const struct rxrpc_call *,

			     u32 *);

void rxrpc_kernel_probe_life(struct socket *, struct rxrpc_call *);

u32 rxrpc_kernel_get_epoch(struct socket *, struct rxrpc_call *);

bool rxrpc_kernel_get_reply_time(struct socket *, struct rxrpc_call *,

				 ktime_t *);

bool rxrpc_kernel_call_is_complete(struct rxrpc_call *);



#endif /* _NET_RXRPC_H */

net/rxrpc/af_rxrpc.c

+9 −5
Original line number Diff line number Diff line
@@ -371,18 +371,22 @@ EXPORT_SYMBOL(rxrpc_kernel_end_call); 
 * rxrpc_kernel_check_life - Check to see whether a call is still alive

 * @sock: The socket the call is on

 * @call: The call to check

 * @_life: Where to store the life value

 *

 * Allow a kernel service to find out whether a call is still alive - ie. we're

 * getting ACKs from the server.  Returns a number representing the life state

 * which can be compared to that returned by a previous call.

 * getting ACKs from the server.  Passes back in *_life a number representing

 * the life state which can be compared to that returned by a previous call and

 * return true if the call is still alive.

 *

 * If the life state stalls, rxrpc_kernel_probe_life() should be called and

 * then 2RTT waited.

 */

u32 rxrpc_kernel_check_life(const struct socket *sock,

			    const struct rxrpc_call *call)

bool rxrpc_kernel_check_life(const struct socket *sock,

			     const struct rxrpc_call *call,

			     u32 *_life)

{

	return call->acks_latest;

	*_life = call->acks_latest;

	return call->state != RXRPC_CALL_COMPLETE;

}

EXPORT_SYMBOL(rxrpc_kernel_check_life);