net/rxrpc/peer.c - kernel/msm-4.9 - Gitiles

 /* peer.c: Rx RPC peer management
  *
  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  */

 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <rxrpc/rxrpc.h>
 #include <rxrpc/transport.h>
 #include <rxrpc/peer.h>
 #include <rxrpc/connection.h>
 #include <rxrpc/call.h>
 #include <rxrpc/message.h>
 #include <linux/udp.h>
 #include <linux/ip.h>
 #include <net/sock.h>
 #include <asm/uaccess.h>
 #include <asm/div64.h>
 #include "internal.h"

 __RXACCT_DECL(atomic_t rxrpc_peer_count);
 LIST_HEAD(rxrpc_peers);
 DECLARE_RWSEM(rxrpc_peers_sem);
 unsigned long rxrpc_peer_timeout = 12 * 60 * 60;

 static void rxrpc_peer_do_timeout(struct rxrpc_peer *peer);

 static void __rxrpc_peer_timeout(rxrpc_timer_t *timer)
 {
 	struct rxrpc_peer *peer =
 		list_entry(timer, struct rxrpc_peer, timeout);

 	_debug("Rx PEER TIMEOUT [%p{u=%d}]", peer, atomic_read(&peer->usage));

 	rxrpc_peer_do_timeout(peer);
 }

 static const struct rxrpc_timer_ops rxrpc_peer_timer_ops = {
 	.timed_out	= __rxrpc_peer_timeout,
 };

 /*****************************************************************************/
 /*
  * create a peer record
  */
 static int __rxrpc_create_peer(struct rxrpc_transport *trans, __be32 addr,
 			       struct rxrpc_peer **_peer)
 {
 	struct rxrpc_peer *peer;

 	_enter("%p,%08x", trans, ntohl(addr));

 	/* allocate and initialise a peer record */
 	peer = kzalloc(sizeof(struct rxrpc_peer), GFP_KERNEL);
 	if (!peer) {
 		_leave(" = -ENOMEM");
 		return -ENOMEM;
 	}

 	atomic_set(&peer->usage, 1);

 	INIT_LIST_HEAD(&peer->link);
 	INIT_LIST_HEAD(&peer->proc_link);
 	INIT_LIST_HEAD(&peer->conn_idlist);
 	INIT_LIST_HEAD(&peer->conn_active);
 	INIT_LIST_HEAD(&peer->conn_graveyard);
 	spin_lock_init(&peer->conn_gylock);
 	init_waitqueue_head(&peer->conn_gy_waitq);
 	rwlock_init(&peer->conn_idlock);
 	rwlock_init(&peer->conn_lock);
 	atomic_set(&peer->conn_count, 0);
 	spin_lock_init(&peer->lock);
 	rxrpc_timer_init(&peer->timeout, &rxrpc_peer_timer_ops);

 	peer->addr.s_addr = addr;

 	peer->trans = trans;
 	peer->ops = trans->peer_ops;

 	__RXACCT(atomic_inc(&rxrpc_peer_count));
 	*_peer = peer;
 	_leave(" = 0 (%p)", peer);

 	return 0;
 } /* end __rxrpc_create_peer() */

 /*****************************************************************************/
 /*
  * find a peer record on the specified transport
  * - returns (if successful) with peer record usage incremented
  * - resurrects it from the graveyard if found there
  */
 int rxrpc_peer_lookup(struct rxrpc_transport *trans, __be32 addr,
 		      struct rxrpc_peer **_peer)
 {
 	struct rxrpc_peer *peer, *candidate = NULL;
 	struct list_head *_p;
 	int ret;

 	_enter("%p{%hu},%08x", trans, trans->port, ntohl(addr));

 	/* [common case] search the transport's active list first */
 	read_lock(&trans->peer_lock);
 	list_for_each(_p, &trans->peer_active) {
 		peer = list_entry(_p, struct rxrpc_peer, link);
 		if (peer->addr.s_addr == addr)
 			goto found_active;
 	}
 	read_unlock(&trans->peer_lock);

 	/* [uncommon case] not active - create a candidate for a new record */
 	ret = __rxrpc_create_peer(trans, addr, &candidate);
 	if (ret < 0) {
 		_leave(" = %d", ret);
 		return ret;
 	}

 	/* search the active list again, just in case it appeared whilst we
 	 * were busy */
 	write_lock(&trans->peer_lock);
 	list_for_each(_p, &trans->peer_active) {
 		peer = list_entry(_p, struct rxrpc_peer, link);
 		if (peer->addr.s_addr == addr)
 			goto found_active_second_chance;
 	}

 	/* search the transport's graveyard list */
 	spin_lock(&trans->peer_gylock);
 	list_for_each(_p, &trans->peer_graveyard) {
 		peer = list_entry(_p, struct rxrpc_peer, link);
 		if (peer->addr.s_addr == addr)
 			goto found_in_graveyard;
 	}
 	spin_unlock(&trans->peer_gylock);

 	/* we can now add the new candidate to the list
 	 * - tell the application layer that this peer has been added
 	 */
 	rxrpc_get_transport(trans);
 	peer = candidate;
 	candidate = NULL;

 	if (peer->ops && peer->ops->adding) {
 		ret = peer->ops->adding(peer);
 		if (ret < 0) {
 			write_unlock(&trans->peer_lock);
 			__RXACCT(atomic_dec(&rxrpc_peer_count));
 			kfree(peer);
 			rxrpc_put_transport(trans);
 			_leave(" = %d", ret);
 			return ret;
 		}
 	}

 	atomic_inc(&trans->peer_count);

  make_active:
 	list_add_tail(&peer->link, &trans->peer_active);

  success_uwfree:
 	write_unlock(&trans->peer_lock);

 	if (candidate) {
 		__RXACCT(atomic_dec(&rxrpc_peer_count));
 		kfree(candidate);
 	}

 	if (list_empty(&peer->proc_link)) {
 		down_write(&rxrpc_peers_sem);
 		list_add_tail(&peer->proc_link, &rxrpc_peers);
 		up_write(&rxrpc_peers_sem);
 	}

  success:
 	*_peer = peer;

 	_leave(" = 0 (%p{u=%d cc=%d})",
 	       peer,
 	       atomic_read(&peer->usage),
 	       atomic_read(&peer->conn_count));
 	return 0;

 	/* handle the peer being found in the active list straight off */
  found_active:
 	rxrpc_get_peer(peer);
 	read_unlock(&trans->peer_lock);
 	goto success;

 	/* handle resurrecting a peer from the graveyard */
  found_in_graveyard:
 	rxrpc_get_peer(peer);
 	rxrpc_get_transport(peer->trans);
 	rxrpc_krxtimod_del_timer(&peer->timeout);
 	list_del_init(&peer->link);
 	spin_unlock(&trans->peer_gylock);
 	goto make_active;

 	/* handle finding the peer on the second time through the active
 	 * list */
  found_active_second_chance:
 	rxrpc_get_peer(peer);
 	goto success_uwfree;

 } /* end rxrpc_peer_lookup() */

 /*****************************************************************************/
 /*
  * finish with a peer record
  * - it gets sent to the graveyard from where it can be resurrected or timed
  *   out
  */
 void rxrpc_put_peer(struct rxrpc_peer *peer)
 {
 	struct rxrpc_transport *trans = peer->trans;

 	_enter("%p{cc=%d a=%08x}",
 	       peer,
 	       atomic_read(&peer->conn_count),
 	       ntohl(peer->addr.s_addr));

 	/* sanity check */
 	if (atomic_read(&peer->usage) <= 0)
 		BUG();

 	write_lock(&trans->peer_lock);
 	spin_lock(&trans->peer_gylock);
 	if (likely(!atomic_dec_and_test(&peer->usage))) {
 		spin_unlock(&trans->peer_gylock);
 		write_unlock(&trans->peer_lock);
 		_leave("");
 		return;
 	}

 	/* move to graveyard queue */
 	list_del(&peer->link);
 	write_unlock(&trans->peer_lock);

 	list_add_tail(&peer->link, &trans->peer_graveyard);

 	BUG_ON(!list_empty(&peer->conn_active));

 	rxrpc_krxtimod_add_timer(&peer->timeout, rxrpc_peer_timeout * HZ);

 	spin_unlock(&trans->peer_gylock);

 	rxrpc_put_transport(trans);

 	_leave(" [killed]");
 } /* end rxrpc_put_peer() */

 /*****************************************************************************/
 /*
  * handle a peer timing out in the graveyard
  * - called from krxtimod
  */
 static void rxrpc_peer_do_timeout(struct rxrpc_peer *peer)
 {
 	struct rxrpc_transport *trans = peer->trans;

 	_enter("%p{u=%d cc=%d a=%08x}",
 	       peer,
 	       atomic_read(&peer->usage),
 	       atomic_read(&peer->conn_count),
 	       ntohl(peer->addr.s_addr));

 	BUG_ON(atomic_read(&peer->usage) < 0);

 	/* remove from graveyard if still dead */
 	spin_lock(&trans->peer_gylock);
 	if (atomic_read(&peer->usage) == 0)
 		list_del_init(&peer->link);
 	else
 		peer = NULL;
 	spin_unlock(&trans->peer_gylock);

 	if (!peer) {
 		_leave("");
 		return; /* resurrected */
 	}

 	/* clear all connections on this peer */
 	rxrpc_conn_clearall(peer);

 	BUG_ON(!list_empty(&peer->conn_active));
 	BUG_ON(!list_empty(&peer->conn_graveyard));

 	/* inform the application layer */
 	if (peer->ops && peer->ops->discarding)
 		peer->ops->discarding(peer);

 	if (!list_empty(&peer->proc_link)) {
 		down_write(&rxrpc_peers_sem);
 		list_del(&peer->proc_link);
 		up_write(&rxrpc_peers_sem);
 	}

 	__RXACCT(atomic_dec(&rxrpc_peer_count));
 	kfree(peer);

 	/* if the graveyard is now empty, wake up anyone waiting for that */
 	if (atomic_dec_and_test(&trans->peer_count))
 		wake_up(&trans->peer_gy_waitq);

 	_leave(" [destroyed]");
 } /* end rxrpc_peer_do_timeout() */

 /*****************************************************************************/
 /*
  * clear all peer records from a transport endpoint
  */
 void rxrpc_peer_clearall(struct rxrpc_transport *trans)
 {
 	DECLARE_WAITQUEUE(myself,current);

 	struct rxrpc_peer *peer;
 	int err;

 	_enter("%p",trans);

 	/* there shouldn't be any active peers remaining */
 	BUG_ON(!list_empty(&trans->peer_active));

 	/* manually timeout all peers in the graveyard */
 	spin_lock(&trans->peer_gylock);
 	while (!list_empty(&trans->peer_graveyard)) {
 		peer = list_entry(trans->peer_graveyard.next,
 				  struct rxrpc_peer, link);
 		_debug("Clearing peer %p\n", peer);
 		err = rxrpc_krxtimod_del_timer(&peer->timeout);
 		spin_unlock(&trans->peer_gylock);

 		if (err == 0)
 			rxrpc_peer_do_timeout(peer);

 		spin_lock(&trans->peer_gylock);
 	}
 	spin_unlock(&trans->peer_gylock);

 	/* wait for the the peer graveyard to be completely cleared */
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	add_wait_queue(&trans->peer_gy_waitq, &myself);

 	while (atomic_read(&trans->peer_count) != 0) {
 		schedule();
 		set_current_state(TASK_UNINTERRUPTIBLE);
 	}

 	remove_wait_queue(&trans->peer_gy_waitq, &myself);
 	set_current_state(TASK_RUNNING);

 	_leave("");
 } /* end rxrpc_peer_clearall() */

 /*****************************************************************************/
 /*
  * calculate and cache the Round-Trip-Time for a message and its response
  */
 void rxrpc_peer_calculate_rtt(struct rxrpc_peer *peer,
 			      struct rxrpc_message *msg,
 			      struct rxrpc_message *resp)
 {
 	unsigned long long rtt;
 	int loop;

 	_enter("%p,%p,%p", peer, msg, resp);

 	/* calculate the latest RTT */
 	rtt = resp->stamp.tv_sec - msg->stamp.tv_sec;
 	rtt *= 1000000UL;
 	rtt += resp->stamp.tv_usec - msg->stamp.tv_usec;

 	/* add to cache */
 	peer->rtt_cache[peer->rtt_point] = rtt;
 	peer->rtt_point++;
 	peer->rtt_point %= RXRPC_RTT_CACHE_SIZE;

 	if (peer->rtt_usage < RXRPC_RTT_CACHE_SIZE)
 		peer->rtt_usage++;

 	/* recalculate RTT */
 	rtt = 0;
 	for (loop = peer->rtt_usage - 1; loop >= 0; loop--)
 		rtt += peer->rtt_cache[loop];

 	do_div(rtt, peer->rtt_usage);
 	peer->rtt = rtt;

 	_leave(" RTT=%lu.%lums",
 	       (long) (peer->rtt / 1000), (long) (peer->rtt % 1000));

 } /* end rxrpc_peer_calculate_rtt() */
	/* peer.c: Rx RPC peer management
	*
	* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
	* Written by David Howells (dhowells@redhat.com)
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; either version
	* 2 of the License, or (at your option) any later version.
	*/

	#include <linux/sched.h>
	#include <linux/slab.h>
	#include <linux/module.h>
	#include <rxrpc/rxrpc.h>
	#include <rxrpc/transport.h>
	#include <rxrpc/peer.h>
	#include <rxrpc/connection.h>
	#include <rxrpc/call.h>
	#include <rxrpc/message.h>
	#include <linux/udp.h>
	#include <linux/ip.h>
	#include <net/sock.h>
	#include <asm/uaccess.h>
	#include <asm/div64.h>
	#include "internal.h"

	__RXACCT_DECL(atomic_t rxrpc_peer_count);
	LIST_HEAD(rxrpc_peers);
	DECLARE_RWSEM(rxrpc_peers_sem);
	unsigned long rxrpc_peer_timeout = 12 * 60 * 60;

	static void rxrpc_peer_do_timeout(struct rxrpc_peer *peer);

	static void __rxrpc_peer_timeout(rxrpc_timer_t *timer)
	{
	struct rxrpc_peer *peer =
	list_entry(timer, struct rxrpc_peer, timeout);

	_debug("Rx PEER TIMEOUT [%p{u=%d}]", peer, atomic_read(&peer->usage));

	rxrpc_peer_do_timeout(peer);
	}

	static const struct rxrpc_timer_ops rxrpc_peer_timer_ops = {
	.timed_out = __rxrpc_peer_timeout,
	};

	/*****************************************************************************/
	/*
	* create a peer record
	*/
	static int __rxrpc_create_peer(struct rxrpc_transport *trans, __be32 addr,
	struct rxrpc_peer **_peer)
	{
	struct rxrpc_peer *peer;

	_enter("%p,%08x", trans, ntohl(addr));

	/* allocate and initialise a peer record */
	peer = kzalloc(sizeof(struct rxrpc_peer), GFP_KERNEL);
	if (!peer) {
	_leave(" = -ENOMEM");
	return -ENOMEM;
	}

	atomic_set(&peer->usage, 1);

	INIT_LIST_HEAD(&peer->link);
	INIT_LIST_HEAD(&peer->proc_link);
	INIT_LIST_HEAD(&peer->conn_idlist);
	INIT_LIST_HEAD(&peer->conn_active);
	INIT_LIST_HEAD(&peer->conn_graveyard);
	spin_lock_init(&peer->conn_gylock);
	init_waitqueue_head(&peer->conn_gy_waitq);
	rwlock_init(&peer->conn_idlock);
	rwlock_init(&peer->conn_lock);
	atomic_set(&peer->conn_count, 0);
	spin_lock_init(&peer->lock);
	rxrpc_timer_init(&peer->timeout, &rxrpc_peer_timer_ops);

	peer->addr.s_addr = addr;

	peer->trans = trans;
	peer->ops = trans->peer_ops;

	__RXACCT(atomic_inc(&rxrpc_peer_count));
	*_peer = peer;
	_leave(" = 0 (%p)", peer);

	return 0;
	} /* end __rxrpc_create_peer() */

	/*****************************************************************************/
	/*
	* find a peer record on the specified transport
	* - returns (if successful) with peer record usage incremented
	* - resurrects it from the graveyard if found there
	*/
	int rxrpc_peer_lookup(struct rxrpc_transport *trans, __be32 addr,
	struct rxrpc_peer **_peer)
	{
	struct rxrpc_peer peer, candidate = NULL;
	struct list_head *_p;
	int ret;

	_enter("%p{%hu},%08x", trans, trans->port, ntohl(addr));

	/* [common case] search the transport's active list first */
	read_lock(&trans->peer_lock);
	list_for_each(_p, &trans->peer_active) {
	peer = list_entry(_p, struct rxrpc_peer, link);
	if (peer->addr.s_addr == addr)
	goto found_active;
	}
	read_unlock(&trans->peer_lock);

	/* [uncommon case] not active - create a candidate for a new record */
	ret = __rxrpc_create_peer(trans, addr, &candidate);
	if (ret < 0) {
	_leave(" = %d", ret);
	return ret;
	}

	/* search the active list again, just in case it appeared whilst we
	* were busy */
	write_lock(&trans->peer_lock);
	list_for_each(_p, &trans->peer_active) {
	peer = list_entry(_p, struct rxrpc_peer, link);
	if (peer->addr.s_addr == addr)
	goto found_active_second_chance;
	}

	/* search the transport's graveyard list */
	spin_lock(&trans->peer_gylock);
	list_for_each(_p, &trans->peer_graveyard) {
	peer = list_entry(_p, struct rxrpc_peer, link);
	if (peer->addr.s_addr == addr)
	goto found_in_graveyard;
	}
	spin_unlock(&trans->peer_gylock);

	/* we can now add the new candidate to the list
	* - tell the application layer that this peer has been added
	*/
	rxrpc_get_transport(trans);
	peer = candidate;
	candidate = NULL;

	if (peer->ops && peer->ops->adding) {
	ret = peer->ops->adding(peer);
	if (ret < 0) {
	write_unlock(&trans->peer_lock);
	__RXACCT(atomic_dec(&rxrpc_peer_count));
	kfree(peer);
	rxrpc_put_transport(trans);
	_leave(" = %d", ret);
	return ret;
	}
	}

	atomic_inc(&trans->peer_count);

	make_active:
	list_add_tail(&peer->link, &trans->peer_active);

	success_uwfree:
	write_unlock(&trans->peer_lock);

	if (candidate) {
	__RXACCT(atomic_dec(&rxrpc_peer_count));
	kfree(candidate);
	}

	if (list_empty(&peer->proc_link)) {
	down_write(&rxrpc_peers_sem);
	list_add_tail(&peer->proc_link, &rxrpc_peers);
	up_write(&rxrpc_peers_sem);
	}

	success:
	*_peer = peer;

	_leave(" = 0 (%p{u=%d cc=%d})",
	peer,
	atomic_read(&peer->usage),
	atomic_read(&peer->conn_count));
	return 0;

	/* handle the peer being found in the active list straight off */
	found_active:
	rxrpc_get_peer(peer);
	read_unlock(&trans->peer_lock);
	goto success;

	/* handle resurrecting a peer from the graveyard */
	found_in_graveyard:
	rxrpc_get_peer(peer);
	rxrpc_get_transport(peer->trans);
	rxrpc_krxtimod_del_timer(&peer->timeout);
	list_del_init(&peer->link);
	spin_unlock(&trans->peer_gylock);
	goto make_active;

	/* handle finding the peer on the second time through the active
	* list */
	found_active_second_chance:
	rxrpc_get_peer(peer);
	goto success_uwfree;

	} /* end rxrpc_peer_lookup() */

	/*****************************************************************************/
	/*
	* finish with a peer record
	* - it gets sent to the graveyard from where it can be resurrected or timed
	* out
	*/
	void rxrpc_put_peer(struct rxrpc_peer *peer)
	{
	struct rxrpc_transport *trans = peer->trans;

	_enter("%p{cc=%d a=%08x}",
	peer,
	atomic_read(&peer->conn_count),
	ntohl(peer->addr.s_addr));

	/* sanity check */
	if (atomic_read(&peer->usage) <= 0)
	BUG();

	write_lock(&trans->peer_lock);
	spin_lock(&trans->peer_gylock);
	if (likely(!atomic_dec_and_test(&peer->usage))) {
	spin_unlock(&trans->peer_gylock);
	write_unlock(&trans->peer_lock);
	_leave("");
	return;
	}

	/* move to graveyard queue */
	list_del(&peer->link);
	write_unlock(&trans->peer_lock);

	list_add_tail(&peer->link, &trans->peer_graveyard);

	BUG_ON(!list_empty(&peer->conn_active));

	rxrpc_krxtimod_add_timer(&peer->timeout, rxrpc_peer_timeout * HZ);

	spin_unlock(&trans->peer_gylock);

	rxrpc_put_transport(trans);

	_leave(" [killed]");
	} /* end rxrpc_put_peer() */

	/*****************************************************************************/
	/*
	* handle a peer timing out in the graveyard
	* - called from krxtimod
	*/
	static void rxrpc_peer_do_timeout(struct rxrpc_peer *peer)
	{
	struct rxrpc_transport *trans = peer->trans;

	_enter("%p{u=%d cc=%d a=%08x}",
	peer,
	atomic_read(&peer->usage),
	atomic_read(&peer->conn_count),
	ntohl(peer->addr.s_addr));

	BUG_ON(atomic_read(&peer->usage) < 0);

	/* remove from graveyard if still dead */
	spin_lock(&trans->peer_gylock);
	if (atomic_read(&peer->usage) == 0)
	list_del_init(&peer->link);
	else
	peer = NULL;
	spin_unlock(&trans->peer_gylock);

	if (!peer) {
	_leave("");
	return; /* resurrected */
	}

	/* clear all connections on this peer */
	rxrpc_conn_clearall(peer);

	BUG_ON(!list_empty(&peer->conn_active));
	BUG_ON(!list_empty(&peer->conn_graveyard));

	/* inform the application layer */
	if (peer->ops && peer->ops->discarding)
	peer->ops->discarding(peer);

	if (!list_empty(&peer->proc_link)) {
	down_write(&rxrpc_peers_sem);
	list_del(&peer->proc_link);
	up_write(&rxrpc_peers_sem);
	}

	__RXACCT(atomic_dec(&rxrpc_peer_count));
	kfree(peer);

	/* if the graveyard is now empty, wake up anyone waiting for that */
	if (atomic_dec_and_test(&trans->peer_count))
	wake_up(&trans->peer_gy_waitq);

	_leave(" [destroyed]");
	} /* end rxrpc_peer_do_timeout() */

	/*****************************************************************************/
	/*
	* clear all peer records from a transport endpoint
	*/
	void rxrpc_peer_clearall(struct rxrpc_transport *trans)
	{
	DECLARE_WAITQUEUE(myself,current);

	struct rxrpc_peer *peer;
	int err;

	_enter("%p",trans);

	/* there shouldn't be any active peers remaining */
	BUG_ON(!list_empty(&trans->peer_active));

	/* manually timeout all peers in the graveyard */
	spin_lock(&trans->peer_gylock);
	while (!list_empty(&trans->peer_graveyard)) {
	peer = list_entry(trans->peer_graveyard.next,
	struct rxrpc_peer, link);
	_debug("Clearing peer %p\n", peer);
	err = rxrpc_krxtimod_del_timer(&peer->timeout);
	spin_unlock(&trans->peer_gylock);

	if (err == 0)
	rxrpc_peer_do_timeout(peer);

	spin_lock(&trans->peer_gylock);
	}
	spin_unlock(&trans->peer_gylock);

	/* wait for the the peer graveyard to be completely cleared */
	set_current_state(TASK_UNINTERRUPTIBLE);
	add_wait_queue(&trans->peer_gy_waitq, &myself);

	while (atomic_read(&trans->peer_count) != 0) {
	schedule();
	set_current_state(TASK_UNINTERRUPTIBLE);
	}

	remove_wait_queue(&trans->peer_gy_waitq, &myself);
	set_current_state(TASK_RUNNING);

	_leave("");
	} /* end rxrpc_peer_clearall() */

	/*****************************************************************************/
	/*
	* calculate and cache the Round-Trip-Time for a message and its response
	*/
	void rxrpc_peer_calculate_rtt(struct rxrpc_peer *peer,
	struct rxrpc_message *msg,
	struct rxrpc_message *resp)
	{
	unsigned long long rtt;
	int loop;

	_enter("%p,%p,%p", peer, msg, resp);

	/* calculate the latest RTT */
	rtt = resp->stamp.tv_sec - msg->stamp.tv_sec;
	rtt *= 1000000UL;
	rtt += resp->stamp.tv_usec - msg->stamp.tv_usec;

	/* add to cache */
	peer->rtt_cache[peer->rtt_point] = rtt;
	peer->rtt_point++;
	peer->rtt_point %= RXRPC_RTT_CACHE_SIZE;

	if (peer->rtt_usage < RXRPC_RTT_CACHE_SIZE)
	peer->rtt_usage++;

	/* recalculate RTT */
	rtt = 0;
	for (loop = peer->rtt_usage - 1; loop >= 0; loop--)
	rtt += peer->rtt_cache[loop];

	do_div(rtt, peer->rtt_usage);
	peer->rtt = rtt;

	_leave(" RTT=%lu.%lums",
	(long) (peer->rtt / 1000), (long) (peer->rtt % 1000));

	} /* end rxrpc_peer_calculate_rtt() */