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

Commit 94f7153e authored by David S. Miller's avatar David S. Miller
Browse files

Merge tag 'rxrpc-rewrite-20160304' of... 

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



David Howells says:

====================
RxRPC: Rewrite part 1

Here's the first set of patches from my RxRPC rewrite, aimed at net-next.
These do some clean ups and bug fixes.  Most of the changes are small, but
there are a couple of bigger changes:

 (*) Convert call flag numbers and event numbers into enums.  Then rename
     the event numbers to all have _EV_ in their name to stop confusion.
     Fix one instance of an event bit being used instead of a flag bit.

 (*) A copy of the Rx protocol header is kept in the sk_buff private data.
     Keep this in host byte order rather than network byte order as it
     makes more sense.  A number of other fields then get converted into
     host byte order too.

     Conversion between host and network byte order is then done at the
     packet reception/generation stage.

This is based on net-next/master
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 3d1c6df8 a4373a48

include/rxrpc/packet.h

+12 −3
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ typedef __be32 rxrpc_serial_net_t; /* on-the-wire Rx message serial number */ 
 * on-the-wire Rx packet header

 * - all multibyte fields should be in network byte order

 */

struct rxrpc_header {

struct rxrpc_wire_header {

	__be32		epoch;		/* client boot timestamp */



	__be32		cid;		/* connection and channel ID */
@@ -68,10 +68,19 @@ struct rxrpc_header { 


} __packed;



#define __rxrpc_header_off(X) offsetof(struct rxrpc_header,X)



extern const char *rxrpc_pkts[];



#define RXRPC_SUPPORTED_PACKET_TYPES (			\

		(1 << RXRPC_PACKET_TYPE_DATA) |		\

		(1 << RXRPC_PACKET_TYPE_ACK) |		\

		(1 << RXRPC_PACKET_TYPE_BUSY) |		\

		(1 << RXRPC_PACKET_TYPE_ABORT) |	\

		(1 << RXRPC_PACKET_TYPE_ACKALL) |	\

		(1 << RXRPC_PACKET_TYPE_CHALLENGE) |	\

		(1 << RXRPC_PACKET_TYPE_RESPONSE) |	\

		/*(1 << RXRPC_PACKET_TYPE_DEBUG) | */	\

		(1 << RXRPC_PACKET_TYPE_VERSION))



/*****************************************************************************/

/*

 * jumbo packet secondary header

net/rxrpc/af_rxrpc.c

+16 −23
Original line number Diff line number Diff line
@@ -37,7 +37,7 @@ static struct proto rxrpc_proto; 
static const struct proto_ops rxrpc_rpc_ops;



/* local epoch for detecting local-end reset */

__be32 rxrpc_epoch;

u32 rxrpc_epoch;



/* current debugging ID */

atomic_t rxrpc_debug_id;
@@ -81,6 +81,8 @@ static int rxrpc_validate_address(struct rxrpc_sock *rx, 
				  struct sockaddr_rxrpc *srx,

				  int len)

{

	unsigned tail;



	if (len < sizeof(struct sockaddr_rxrpc))

		return -EINVAL;
@@ -103,9 +105,7 @@ static int rxrpc_validate_address(struct rxrpc_sock *rx, 
		_debug("INET: %x @ %pI4",

		       ntohs(srx->transport.sin.sin_port),

		       &srx->transport.sin.sin_addr);

		if (srx->transport_len > 8)

			memset((void *)&srx->transport + 8, 0,

			       srx->transport_len - 8);

		tail = offsetof(struct sockaddr_rxrpc, transport.sin.__pad);

		break;



	case AF_INET6:
@@ -113,6 +113,8 @@ static int rxrpc_validate_address(struct rxrpc_sock *rx, 
		return -EAFNOSUPPORT;

	}



	if (tail < len)

		memset((void *)srx + tail, 0, len - tail);

	return 0;

}
@@ -125,7 +127,6 @@ static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len) 
	struct sock *sk = sock->sk;

	struct rxrpc_local *local;

	struct rxrpc_sock *rx = rxrpc_sk(sk), *prx;

	__be16 service_id;

	int ret;



	_enter("%p,%p,%d", rx, saddr, len);
@@ -143,7 +144,7 @@ static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len) 


	memcpy(&rx->srx, srx, sizeof(rx->srx));



	/* find a local transport endpoint if we don't have one already */

	/* Find or create a local transport endpoint to use */

	local = rxrpc_lookup_local(&rx->srx);

	if (IS_ERR(local)) {

		ret = PTR_ERR(local);
@@ -152,14 +153,12 @@ static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len) 


	rx->local = local;

	if (srx->srx_service) {

		service_id = htons(srx->srx_service);

		write_lock_bh(&local->services_lock);

		list_for_each_entry(prx, &local->services, listen_link) {

			if (prx->service_id == service_id)

			if (prx->srx.srx_service == srx->srx_service)

				goto service_in_use;

		}



		rx->service_id = service_id;

		list_add_tail(&rx->listen_link, &local->services);

		write_unlock_bh(&local->services_lock);
@@ -276,7 +275,6 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock, 
	struct rxrpc_transport *trans;

	struct rxrpc_call *call;

	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);

	__be16 service_id;



	_enter(",,%x,%lx", key_serial(key), user_call_ID);
@@ -299,16 +297,14 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock, 
		atomic_inc(&trans->usage);

	}



	service_id = rx->service_id;

	if (srx)

		service_id = htons(srx->srx_service);



	if (!srx)

		srx = &rx->srx;

	if (!key)

		key = rx->key;

	if (key && !key->payload.data[0])

		key = NULL; /* a no-security key */



	bundle = rxrpc_get_bundle(rx, trans, key, service_id, gfp);

	bundle = rxrpc_get_bundle(rx, trans, key, srx->srx_service, gfp);

	if (IS_ERR(bundle)) {

		call = ERR_CAST(bundle);

		goto out;
@@ -324,7 +320,6 @@ struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock, 
	_leave(" = %p", call);

	return call;

}



EXPORT_SYMBOL(rxrpc_kernel_begin_call);



/**
@@ -340,7 +335,6 @@ void rxrpc_kernel_end_call(struct rxrpc_call *call) 
	rxrpc_remove_user_ID(call->socket, call);

	rxrpc_put_call(call);

}



EXPORT_SYMBOL(rxrpc_kernel_end_call);



/**
@@ -425,7 +419,6 @@ static int rxrpc_connect(struct socket *sock, struct sockaddr *addr, 
	}



	rx->trans = trans;

	rx->service_id = htons(srx->srx_service);

	rx->sk.sk_state = RXRPC_CLIENT_CONNECTED;



	release_sock(&rx->sk);
@@ -622,7 +615,7 @@ static int rxrpc_create(struct net *net, struct socket *sock, int protocol, 
	if (!net_eq(net, &init_net))

		return -EAFNOSUPPORT;



	/* we support transport protocol UDP only */

	/* we support transport protocol UDP/UDP6 only */

	if (protocol != PF_INET)

		return -EPROTONOSUPPORT;
@@ -754,7 +747,7 @@ static int rxrpc_release(struct socket *sock) 
 * RxRPC network protocol

 */

static const struct proto_ops rxrpc_rpc_ops = {

	.family		= PF_UNIX,

	.family		= PF_RXRPC,

	.owner		= THIS_MODULE,

	.release	= rxrpc_release,

	.bind		= rxrpc_bind,
@@ -778,7 +771,7 @@ static struct proto rxrpc_proto = { 
	.name		= "RXRPC",

	.owner		= THIS_MODULE,

	.obj_size	= sizeof(struct rxrpc_sock),

	.max_header	= sizeof(struct rxrpc_header),

	.max_header	= sizeof(struct rxrpc_wire_header),

};



static const struct net_proto_family rxrpc_family_ops = {
@@ -796,7 +789,7 @@ static int __init af_rxrpc_init(void) 


	BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > FIELD_SIZEOF(struct sk_buff, cb));



	rxrpc_epoch = htonl(get_seconds());

	rxrpc_epoch = get_seconds();



	ret = -ENOMEM;

	rxrpc_call_jar = kmem_cache_create(

net/rxrpc/ar-accept.c

+31 −25
Original line number Diff line number Diff line
@@ -27,7 +27,7 @@ 
 * generate a connection-level abort

 */

static int rxrpc_busy(struct rxrpc_local *local, struct sockaddr_rxrpc *srx,

		      struct rxrpc_header *hdr)

		      struct rxrpc_wire_header *whdr)

{

	struct msghdr msg;

	struct kvec iov[1];
@@ -36,25 +36,21 @@ static int rxrpc_busy(struct rxrpc_local *local, struct sockaddr_rxrpc *srx, 


	_enter("%d,,", local->debug_id);



	whdr->type	= RXRPC_PACKET_TYPE_BUSY;

	whdr->serial	= htonl(1);



	msg.msg_name	= &srx->transport.sin;

	msg.msg_namelen	= sizeof(srx->transport.sin);

	msg.msg_control	= NULL;

	msg.msg_controllen = 0;

	msg.msg_flags	= 0;



	hdr->seq	= 0;

	hdr->type	= RXRPC_PACKET_TYPE_BUSY;

	hdr->flags	= 0;

	hdr->userStatus	= 0;

	hdr->_rsvd	= 0;



	iov[0].iov_base	= hdr;

	iov[0].iov_len	= sizeof(*hdr);

	iov[0].iov_base	= whdr;

	iov[0].iov_len	= sizeof(*whdr);



	len = iov[0].iov_len;



	hdr->serial = htonl(1);

	_proto("Tx BUSY %%%u", ntohl(hdr->serial));

	_proto("Tx BUSY %%1");



	ret = kernel_sendmsg(local->socket, &msg, iov, 1, len);

	if (ret < 0) {
@@ -185,8 +181,8 @@ static int rxrpc_accept_incoming_call(struct rxrpc_local *local, 
	read_unlock_bh(&local->services_lock);



	read_lock_bh(&call->state_lock);

	if (!test_bit(RXRPC_CALL_RELEASE, &call->flags) &&

	    !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events)) {

	if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&

	    !test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events)) {

		rxrpc_get_call(call);

		rxrpc_queue_call(call);

	}
@@ -211,8 +207,8 @@ void rxrpc_accept_incoming_calls(struct work_struct *work) 
	struct rxrpc_skb_priv *sp;

	struct sockaddr_rxrpc srx;

	struct rxrpc_sock *rx;

	struct rxrpc_wire_header whdr;

	struct sk_buff *skb;

	__be16 service_id;

	int ret;



	_enter("%d", local->debug_id);
@@ -240,6 +236,19 @@ void rxrpc_accept_incoming_calls(struct work_struct *work) 


	sp = rxrpc_skb(skb);



	/* Set up a response packet header in case we need it */

	whdr.epoch	= htonl(sp->hdr.epoch);

	whdr.cid	= htonl(sp->hdr.cid);

	whdr.callNumber	= htonl(sp->hdr.callNumber);

	whdr.seq	= htonl(sp->hdr.seq);

	whdr.serial	= 0;

	whdr.flags	= 0;

	whdr.type	= 0;

	whdr.userStatus	= 0;

	whdr.securityIndex = sp->hdr.securityIndex;

	whdr._rsvd	= 0;

	whdr.serviceId	= htons(sp->hdr.serviceId);



	/* determine the remote address */

	memset(&srx, 0, sizeof(srx));

	srx.srx_family = AF_RXRPC;
@@ -256,10 +265,9 @@ void rxrpc_accept_incoming_calls(struct work_struct *work) 
	}



	/* get the socket providing the service */

	service_id = sp->hdr.serviceId;

	read_lock_bh(&local->services_lock);

	list_for_each_entry(rx, &local->services, listen_link) {

		if (rx->service_id == service_id &&

		if (rx->srx.srx_service == sp->hdr.serviceId &&

		    rx->sk.sk_state != RXRPC_CLOSE)

			goto found_service;

	}
@@ -267,7 +275,7 @@ void rxrpc_accept_incoming_calls(struct work_struct *work) 
	goto invalid_service;



found_service:

	_debug("found service %hd", ntohs(rx->service_id));

	_debug("found service %hd", rx->srx.srx_service);

	if (sk_acceptq_is_full(&rx->sk))

		goto backlog_full;

	sk_acceptq_added(&rx->sk);
@@ -296,7 +304,7 @@ void rxrpc_accept_incoming_calls(struct work_struct *work) 
backlog_full:

	read_unlock_bh(&local->services_lock);

busy:

	rxrpc_busy(local, &srx, &sp->hdr);

	rxrpc_busy(local, &srx, &whdr);

	rxrpc_free_skb(skb);

	goto process_next_packet;
@@ -379,7 +387,7 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx, 
	rb_insert_color(&call->sock_node, &rx->calls);

	if (test_and_set_bit(RXRPC_CALL_HAS_USERID, &call->flags))

		BUG();

	if (test_and_set_bit(RXRPC_CALL_ACCEPTED, &call->events))

	if (test_and_set_bit(RXRPC_CALL_EV_ACCEPTED, &call->events))

		BUG();

	rxrpc_queue_call(call);
@@ -395,7 +403,7 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx, 
out_release:

	_debug("release %p", call);

	if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&

	    !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))

	    !test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))

		rxrpc_queue_call(call);

out_discard:

	write_unlock_bh(&call->state_lock);
@@ -407,7 +415,7 @@ struct rxrpc_call *rxrpc_accept_call(struct rxrpc_sock *rx, 
}



/*

 * handle rejectance of a call by userspace

 * Handle rejection of a call by userspace

 * - reject the call at the front of the queue

 */

int rxrpc_reject_call(struct rxrpc_sock *rx)
@@ -434,7 +442,7 @@ int rxrpc_reject_call(struct rxrpc_sock *rx) 
	switch (call->state) {

	case RXRPC_CALL_SERVER_ACCEPTING:

		call->state = RXRPC_CALL_SERVER_BUSY;

		if (test_and_set_bit(RXRPC_CALL_REJECT_BUSY, &call->events))

		if (test_and_set_bit(RXRPC_CALL_EV_REJECT_BUSY, &call->events))

			rxrpc_queue_call(call);

		ret = 0;

		goto out_release;
@@ -458,7 +466,7 @@ int rxrpc_reject_call(struct rxrpc_sock *rx) 
out_release:

	_debug("release %p", call);

	if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&

	    !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))

	    !test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))

		rxrpc_queue_call(call);

out_discard:

	write_unlock_bh(&call->state_lock);
@@ -487,7 +495,6 @@ struct rxrpc_call *rxrpc_kernel_accept_call(struct socket *sock, 
	_leave(" = %p", call);

	return call;

}



EXPORT_SYMBOL(rxrpc_kernel_accept_call);



/**
@@ -506,5 +513,4 @@ int rxrpc_kernel_reject_call(struct socket *sock) 
	_leave(" = %d", ret);

	return ret;

}



EXPORT_SYMBOL(rxrpc_kernel_reject_call);

net/rxrpc/ar-ack.c

+104 −109

File changed.

Preview size limit exceeded, changes collapsed.

net/rxrpc/ar-call.c

+40 −44
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ unsigned rxrpc_max_call_lifetime = 60 * HZ; 
 */

unsigned rxrpc_dead_call_expiry = 2 * HZ;



const char *const rxrpc_call_states[] = {

const char *const rxrpc_call_states[NR__RXRPC_CALL_STATES] = {

	[RXRPC_CALL_CLIENT_SEND_REQUEST]	= "ClSndReq",

	[RXRPC_CALL_CLIENT_AWAIT_REPLY]		= "ClAwtRpl",

	[RXRPC_CALL_CLIENT_RECV_REPLY]		= "ClRcvRpl",
@@ -64,11 +64,11 @@ static DEFINE_HASHTABLE(rxrpc_call_hash, 10); 
 * Hash function for rxrpc_call_hash

 */

static unsigned long rxrpc_call_hashfunc(

	u8		clientflag,

	__be32		cid,

	__be32		call_id,

	__be32		epoch,

	__be16		service_id,

	u8		in_clientflag,

	u32		cid,

	u32		call_id,

	u32		epoch,

	u16		service_id,

	sa_family_t	proto,

	void		*localptr,

	unsigned int	addr_size,
@@ -77,7 +77,6 @@ static unsigned long rxrpc_call_hashfunc( 
	const u16 *p;

	unsigned int i;

	unsigned long key;

	u32 hcid = ntohl(cid);



	_enter("");
@@ -85,12 +84,12 @@ static unsigned long rxrpc_call_hashfunc( 
	/* We just want to add up the __be32 values, so forcing the

	 * cast should be okay.

	 */

	key += (__force u32)epoch;

	key += (__force u16)service_id;

	key += (__force u32)call_id;

	key += (hcid & RXRPC_CIDMASK) >> RXRPC_CIDSHIFT;

	key += hcid & RXRPC_CHANNELMASK;

	key += clientflag;

	key += epoch;

	key += service_id;

	key += call_id;

	key += (cid & RXRPC_CIDMASK) >> RXRPC_CIDSHIFT;

	key += cid & RXRPC_CHANNELMASK;

	key += in_clientflag;

	key += proto;

	/* Step through the peer address in 16-bit portions for speed */

	for (i = 0, p = (const u16 *)peer_addr; i < addr_size >> 1; i++, p++)
@@ -148,19 +147,16 @@ static void rxrpc_call_hash_del(struct rxrpc_call *call) 
 * isn't there.

 */

struct rxrpc_call *rxrpc_find_call_hash(

	u8		clientflag,

	__be32		cid,

	__be32		call_id,

	__be32		epoch,

	__be16		service_id,

	struct rxrpc_host_header *hdr,

	void		*localptr,

	sa_family_t	proto,

	const u8	*peer_addr)

	const void	*peer_addr)

{

	unsigned long key;

	unsigned int addr_size = 0;

	struct rxrpc_call *call = NULL;

	struct rxrpc_call *ret = NULL;

	u8 in_clientflag = hdr->flags & RXRPC_CLIENT_INITIATED;



	_enter("");

	switch (proto) {
@@ -174,20 +170,21 @@ struct rxrpc_call *rxrpc_find_call_hash( 
		break;

	}



	key = rxrpc_call_hashfunc(clientflag, cid, call_id, epoch,

				  service_id, proto, localptr, addr_size,

	key = rxrpc_call_hashfunc(in_clientflag, hdr->cid, hdr->callNumber,

				  hdr->epoch, hdr->serviceId,

				  proto, localptr, addr_size,

				  peer_addr);

	hash_for_each_possible_rcu(rxrpc_call_hash, call, hash_node, key) {

		if (call->hash_key == key &&

		    call->call_id == call_id &&

		    call->cid == cid &&

		    call->in_clientflag == clientflag &&

		    call->service_id == service_id &&

		    call->call_id == hdr->callNumber &&

		    call->cid == hdr->cid &&

		    call->in_clientflag == in_clientflag &&

		    call->service_id == hdr->serviceId &&

		    call->proto == proto &&

		    call->local == localptr &&

		    memcmp(call->peer_ip.ipv6_addr, peer_addr,

			   addr_size) == 0 &&

		    call->epoch == epoch) {

		    call->epoch == hdr->epoch) {

			ret = call;

			break;

		}
@@ -414,12 +411,12 @@ struct rxrpc_call *rxrpc_get_client_call(struct rxrpc_sock *rx, 
 */

struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx,

				       struct rxrpc_connection *conn,

				       struct rxrpc_header *hdr,

				       struct rxrpc_host_header *hdr,

				       gfp_t gfp)

{

	struct rxrpc_call *call, *candidate;

	struct rb_node **p, *parent;

	__be32 call_id;

	u32 call_id;



	_enter(",%d,,%x", conn->debug_id, gfp);
@@ -433,7 +430,7 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx, 
	candidate->conn = conn;

	candidate->cid = hdr->cid;

	candidate->call_id = hdr->callNumber;

	candidate->channel = ntohl(hdr->cid) & RXRPC_CHANNELMASK;

	candidate->channel = hdr->cid & RXRPC_CHANNELMASK;

	candidate->rx_data_post = 0;

	candidate->state = RXRPC_CALL_SERVER_ACCEPTING;

	if (conn->security_ix > 0)
@@ -452,7 +449,7 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx, 
		read_lock(&call->state_lock);

		switch (call->state) {

		case RXRPC_CALL_LOCALLY_ABORTED:

			if (!test_and_set_bit(RXRPC_CALL_ABORT, &call->events))

			if (!test_and_set_bit(RXRPC_CALL_EV_ABORT, &call->events))

				rxrpc_queue_call(call);

		case RXRPC_CALL_REMOTELY_ABORTED:

			read_unlock(&call->state_lock);
@@ -492,9 +489,9 @@ struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx, 
		/* The tree is sorted in order of the __be32 value without

		 * turning it into host order.

		 */

		if ((__force u32)call_id < (__force u32)call->call_id)

		if (call_id < call->call_id)

			p = &(*p)->rb_left;

		else if ((__force u32)call_id > (__force u32)call->call_id)

		else if (call_id > call->call_id)

			p = &(*p)->rb_right;

		else

			goto old_call;
@@ -686,7 +683,7 @@ void rxrpc_release_call(struct rxrpc_call *call) 
		_debug("+++ ABORTING STATE %d +++\n", call->state);

		call->state = RXRPC_CALL_LOCALLY_ABORTED;

		call->abort_code = RX_CALL_DEAD;

		set_bit(RXRPC_CALL_ABORT, &call->events);

		set_bit(RXRPC_CALL_EV_ABORT, &call->events);

		rxrpc_queue_call(call);

	}

	write_unlock(&call->state_lock);
@@ -714,8 +711,7 @@ void rxrpc_release_call(struct rxrpc_call *call) 


			_debug("- zap %s %%%u #%u",

			       rxrpc_pkts[sp->hdr.type],

			       ntohl(sp->hdr.serial),

			       ntohl(sp->hdr.seq));

			       sp->hdr.serial, sp->hdr.seq);

			rxrpc_free_skb(skb);

			spin_lock_bh(&call->lock);

		}
@@ -763,10 +759,10 @@ static void rxrpc_mark_call_released(struct rxrpc_call *call) 
			_debug("abort call %p", call);

			call->state = RXRPC_CALL_LOCALLY_ABORTED;

			call->abort_code = RX_CALL_DEAD;

			if (!test_and_set_bit(RXRPC_CALL_ABORT, &call->events))

			if (!test_and_set_bit(RXRPC_CALL_EV_ABORT, &call->events))

				sched = true;

		}

		if (!test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))

		if (!test_and_set_bit(RXRPC_CALL_EV_RELEASE, &call->events))

			sched = true;

		if (sched)

			rxrpc_queue_call(call);
@@ -874,7 +870,7 @@ static void rxrpc_cleanup_call(struct rxrpc_call *call) 


			_skb = call->acks_window[call->acks_tail] & ~1;

			sp = rxrpc_skb((struct sk_buff *)_skb);

			_debug("+++ clear Tx %u", ntohl(sp->hdr.seq));

			_debug("+++ clear Tx %u", sp->hdr.seq);

			rxrpc_free_skb((struct sk_buff *)_skb);

			call->acks_tail =

				(call->acks_tail + 1) & (call->acks_winsz - 1);
@@ -975,7 +971,7 @@ static void rxrpc_call_life_expired(unsigned long _call) 
	_enter("{%d}", call->debug_id);

	read_lock_bh(&call->state_lock);

	if (call->state < RXRPC_CALL_COMPLETE) {

		set_bit(RXRPC_CALL_LIFE_TIMER, &call->events);

		set_bit(RXRPC_CALL_EV_LIFE_TIMER, &call->events);

		rxrpc_queue_call(call);

	}

	read_unlock_bh(&call->state_lock);
@@ -995,7 +991,7 @@ static void rxrpc_resend_time_expired(unsigned long _call) 
		return;



	clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);

	if (!test_and_set_bit(RXRPC_CALL_RESEND_TIMER, &call->events))

	if (!test_and_set_bit(RXRPC_CALL_EV_RESEND_TIMER, &call->events))

		rxrpc_queue_call(call);

}
@@ -1013,7 +1009,7 @@ static void rxrpc_ack_time_expired(unsigned long _call) 


	read_lock_bh(&call->state_lock);

	if (call->state < RXRPC_CALL_COMPLETE &&

	    !test_and_set_bit(RXRPC_CALL_ACK, &call->events))

	    !test_and_set_bit(RXRPC_CALL_EV_ACK, &call->events))

		rxrpc_queue_call(call);

	read_unlock_bh(&call->state_lock);

}