/* RxRPC point-to-point transport session management
   *
   * Copyright (C) 2007 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/module.h>
  #include <linux/net.h>
  #include <linux/skbuff.h>
  #include <linux/slab.h>
  #include <net/sock.h>
  #include <net/af_rxrpc.h>
  #include "ar-internal.h"
  
  static void rxrpc_transport_reaper(struct work_struct *work);
  
  static LIST_HEAD(rxrpc_transports);
  static DEFINE_RWLOCK(rxrpc_transport_lock);
  static unsigned long rxrpc_transport_timeout = 3600 * 24;
  static DECLARE_DELAYED_WORK(rxrpc_transport_reap, rxrpc_transport_reaper);
  
  /*
   * allocate a new transport session manager
   */
  static struct rxrpc_transport *rxrpc_alloc_transport(struct rxrpc_local *local,
  						     struct rxrpc_peer *peer,
  						     gfp_t gfp)
  {
  	struct rxrpc_transport *trans;
  
  	_enter("");
  
  	trans = kzalloc(sizeof(struct rxrpc_transport), gfp);
  	if (trans) {
  		trans->local = local;
  		trans->peer = peer;
  		INIT_LIST_HEAD(&trans->link);
  		trans->bundles = RB_ROOT;
  		trans->client_conns = RB_ROOT;
  		trans->server_conns = RB_ROOT;
  		skb_queue_head_init(&trans->error_queue);
  		spin_lock_init(&trans->client_lock);
  		rwlock_init(&trans->conn_lock);
  		atomic_set(&trans->usage, 1);
  		trans->debug_id = atomic_inc_return(&rxrpc_debug_id);
  
  		if (peer->srx.transport.family == AF_INET) {
  			switch (peer->srx.transport_type) {
  			case SOCK_DGRAM:
  				INIT_WORK(&trans->error_handler,
  					  rxrpc_UDP_error_handler);
  				break;
  			default:
  				BUG();
  				break;
  			}
  		} else {
  			BUG();
  		}
  	}
  
  	_leave(" = %p", trans);
  	return trans;
  }
  
  /*
   * obtain a transport session for the nominated endpoints
   */
  struct rxrpc_transport *rxrpc_get_transport(struct rxrpc_local *local,
  					    struct rxrpc_peer *peer,
  					    gfp_t gfp)
  {
  	struct rxrpc_transport *trans, *candidate;
  	const char *new = "old";
  	int usage;
  
  	_enter("{%pI4+%hu},{%pI4+%hu},",
  	       &local->srx.transport.sin.sin_addr,
  	       ntohs(local->srx.transport.sin.sin_port),
  	       &peer->srx.transport.sin.sin_addr,
  	       ntohs(peer->srx.transport.sin.sin_port));
  
  	/* search the transport list first */
  	read_lock_bh(&rxrpc_transport_lock);
  	list_for_each_entry(trans, &rxrpc_transports, link) {
  		if (trans->local == local && trans->peer == peer)
  			goto found_extant_transport;
  	}
  	read_unlock_bh(&rxrpc_transport_lock);
  
  	/* not yet present - create a candidate for a new record and then
  	 * redo the search */
  	candidate = rxrpc_alloc_transport(local, peer, gfp);
  	if (!candidate) {
  		_leave(" = -ENOMEM");
  		return ERR_PTR(-ENOMEM);
  	}
  
  	write_lock_bh(&rxrpc_transport_lock);
  
  	list_for_each_entry(trans, &rxrpc_transports, link) {
  		if (trans->local == local && trans->peer == peer)
  			goto found_extant_second;
  	}
  
  	/* we can now add the new candidate to the list */
  	trans = candidate;
  	candidate = NULL;
  	usage = atomic_read(&trans->usage);
  
  	rxrpc_get_local(trans->local);
  	atomic_inc(&trans->peer->usage);
  	list_add_tail(&trans->link, &rxrpc_transports);
  	write_unlock_bh(&rxrpc_transport_lock);
  	new = "new";
  
  success:
  	_net("TRANSPORT %s %d local %d -> peer %d",
  	     new,
  	     trans->debug_id,
  	     trans->local->debug_id,
  	     trans->peer->debug_id);
  
  	_leave(" = %p {u=%d}", trans, usage);
  	return trans;
  
  	/* we found the transport in the list immediately */
  found_extant_transport:
  	usage = atomic_inc_return(&trans->usage);
  	read_unlock_bh(&rxrpc_transport_lock);
  	goto success;
  
  	/* we found the transport on the second time through the list */
  found_extant_second:
  	usage = atomic_inc_return(&trans->usage);
  	write_unlock_bh(&rxrpc_transport_lock);
  	kfree(candidate);
  	goto success;
  }
  
  /*
   * find the transport connecting two endpoints
   */
  struct rxrpc_transport *rxrpc_find_transport(struct rxrpc_local *local,
  					     struct rxrpc_peer *peer)
  {
  	struct rxrpc_transport *trans;
  
  	_enter("{%pI4+%hu},{%pI4+%hu},",
  	       &local->srx.transport.sin.sin_addr,
  	       ntohs(local->srx.transport.sin.sin_port),
  	       &peer->srx.transport.sin.sin_addr,
  	       ntohs(peer->srx.transport.sin.sin_port));
  
  	/* search the transport list */
  	read_lock_bh(&rxrpc_transport_lock);
  
  	list_for_each_entry(trans, &rxrpc_transports, link) {
  		if (trans->local == local && trans->peer == peer)
  			goto found_extant_transport;
  	}
  
  	read_unlock_bh(&rxrpc_transport_lock);
  	_leave(" = NULL");
  	return NULL;
  
  found_extant_transport:
  	atomic_inc(&trans->usage);
  	read_unlock_bh(&rxrpc_transport_lock);
  	_leave(" = %p", trans);
  	return trans;
  }
  
  /*
   * release a transport session
   */
  void rxrpc_put_transport(struct rxrpc_transport *trans)
  {
  	_enter("%p{u=%d}", trans, atomic_read(&trans->usage));
  
  	ASSERTCMP(atomic_read(&trans->usage), >, 0);
  
  	trans->put_time = get_seconds();
  	if (unlikely(atomic_dec_and_test(&trans->usage))) {
  		_debug("zombie");
  		/* let the reaper determine the timeout to avoid a race with
  		 * overextending the timeout if the reaper is running at the
  		 * same time */
  		rxrpc_queue_delayed_work(&rxrpc_transport_reap, 0);
  	}
  	_leave("");
  }
  
  /*
   * clean up a transport session
   */
  static void rxrpc_cleanup_transport(struct rxrpc_transport *trans)
  {
  	_net("DESTROY TRANS %d", trans->debug_id);
  
  	rxrpc_purge_queue(&trans->error_queue);
  
  	rxrpc_put_local(trans->local);
  	rxrpc_put_peer(trans->peer);
  	kfree(trans);
  }
  
  /*
   * reap dead transports that have passed their expiry date
   */
  static void rxrpc_transport_reaper(struct work_struct *work)
  {
  	struct rxrpc_transport *trans, *_p;
  	unsigned long now, earliest, reap_time;
  
  	LIST_HEAD(graveyard);
  
  	_enter("");
  
  	now = get_seconds();
  	earliest = ULONG_MAX;
  
  	/* extract all the transports that have been dead too long */
  	write_lock_bh(&rxrpc_transport_lock);
  	list_for_each_entry_safe(trans, _p, &rxrpc_transports, link) {
  		_debug("reap TRANS %d { u=%d t=%ld }",
  		       trans->debug_id, atomic_read(&trans->usage),
  		       (long) now - (long) trans->put_time);
  
  		if (likely(atomic_read(&trans->usage) > 0))
  			continue;
  
  		reap_time = trans->put_time + rxrpc_transport_timeout;
  		if (reap_time <= now)
  			list_move_tail(&trans->link, &graveyard);
  		else if (reap_time < earliest)
  			earliest = reap_time;
  	}
  	write_unlock_bh(&rxrpc_transport_lock);
  
  	if (earliest != ULONG_MAX) {
  		_debug("reschedule reaper %ld", (long) earliest - now);
  		ASSERTCMP(earliest, >, now);
  		rxrpc_queue_delayed_work(&rxrpc_transport_reap,
  					 (earliest - now) * HZ);
  	}
  
  	/* then destroy all those pulled out */
  	while (!list_empty(&graveyard)) {
  		trans = list_entry(graveyard.next, struct rxrpc_transport,
  				   link);
  		list_del_init(&trans->link);
  
  		ASSERTCMP(atomic_read(&trans->usage), ==, 0);
  		rxrpc_cleanup_transport(trans);
  	}
  
  	_leave("");
  }
  
  /*
   * preemptively destroy all the transport session records rather than waiting
   * for them to time out
   */
  void __exit rxrpc_destroy_all_transports(void)
  {
  	_enter("");
  
  	rxrpc_transport_timeout = 0;
  	cancel_delayed_work(&rxrpc_transport_reap);
  	rxrpc_queue_delayed_work(&rxrpc_transport_reap, 0);
  
  	_leave("");
  }