[linux-2.6-block.git] / net / rxrpc / net_ns.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* rxrpc network namespace handling.
 *
 * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#include <linux/proc_fs.h>
#include "ar-internal.h"

unsigned int rxrpc_net_id;

static void rxrpc_client_conn_reap_timeout(struct timer_list *timer)
{
	struct rxrpc_net *rxnet =
		container_of(timer, struct rxrpc_net, client_conn_reap_timer);

	if (rxnet->live)
		rxrpc_queue_work(&rxnet->client_conn_reaper);
}

static void rxrpc_service_conn_reap_timeout(struct timer_list *timer)
{
	struct rxrpc_net *rxnet =
		container_of(timer, struct rxrpc_net, service_conn_reap_timer);

	if (rxnet->live)
		rxrpc_queue_work(&rxnet->service_conn_reaper);
}

static void rxrpc_peer_keepalive_timeout(struct timer_list *timer)
{
	struct rxrpc_net *rxnet =
		container_of(timer, struct rxrpc_net, peer_keepalive_timer);

	if (rxnet->live)
		rxrpc_queue_work(&rxnet->peer_keepalive_work);
}

/*
 * Initialise a per-network namespace record.
 */
static __net_init int rxrpc_init_net(struct net *net)
{
	struct rxrpc_net *rxnet = rxrpc_net(net);
	int ret, i;

	rxnet->live = true;
	get_random_bytes(&rxnet->epoch, sizeof(rxnet->epoch));
	rxnet->epoch |= RXRPC_RANDOM_EPOCH;

	INIT_LIST_HEAD(&rxnet->calls);
	rwlock_init(&rxnet->call_lock);
	atomic_set(&rxnet->nr_calls, 1);

	atomic_set(&rxnet->nr_conns, 1);
	INIT_LIST_HEAD(&rxnet->conn_proc_list);
	INIT_LIST_HEAD(&rxnet->service_conns);
	rwlock_init(&rxnet->conn_lock);
	INIT_WORK(&rxnet->service_conn_reaper,
		  rxrpc_service_connection_reaper);
	timer_setup(&rxnet->service_conn_reap_timer,
		    rxrpc_service_conn_reap_timeout, 0);

	rxnet->nr_client_conns = 0;
	rxnet->nr_active_client_conns = 0;
	rxnet->kill_all_client_conns = false;
	spin_lock_init(&rxnet->client_conn_cache_lock);
	spin_lock_init(&rxnet->client_conn_discard_lock);
	INIT_LIST_HEAD(&rxnet->waiting_client_conns);
	INIT_LIST_HEAD(&rxnet->active_client_conns);
	INIT_LIST_HEAD(&rxnet->idle_client_conns);
	INIT_WORK(&rxnet->client_conn_reaper,
		  rxrpc_discard_expired_client_conns);
	timer_setup(&rxnet->client_conn_reap_timer,
		    rxrpc_client_conn_reap_timeout, 0);

	INIT_LIST_HEAD(&rxnet->local_endpoints);
	mutex_init(&rxnet->local_mutex);

	hash_init(rxnet->peer_hash);
	spin_lock_init(&rxnet->peer_hash_lock);
	for (i = 0; i < ARRAY_SIZE(rxnet->peer_keepalive); i++)
		INIT_LIST_HEAD(&rxnet->peer_keepalive[i]);
	INIT_LIST_HEAD(&rxnet->peer_keepalive_new);
	timer_setup(&rxnet->peer_keepalive_timer,
		    rxrpc_peer_keepalive_timeout, 0);
	INIT_WORK(&rxnet->peer_keepalive_work, rxrpc_peer_keepalive_worker);
	rxnet->peer_keepalive_base = ktime_get_seconds();

	ret = -ENOMEM;
	rxnet->proc_net = proc_net_mkdir(net, "rxrpc", net->proc_net);
	if (!rxnet->proc_net)
		goto err_proc;

	proc_create_net("calls", 0444, rxnet->proc_net, &rxrpc_call_seq_ops,
			sizeof(struct seq_net_private));
	proc_create_net("conns", 0444, rxnet->proc_net,
			&rxrpc_connection_seq_ops,
			sizeof(struct seq_net_private));
	proc_create_net("peers", 0444, rxnet->proc_net,
			&rxrpc_peer_seq_ops,
			sizeof(struct seq_net_private));
	return 0;

err_proc:
	rxnet->live = false;
	return ret;
}

/*
 * Clean up a per-network namespace record.
 */
static __net_exit void rxrpc_exit_net(struct net *net)
{
	struct rxrpc_net *rxnet = rxrpc_net(net);

	rxnet->live = false;
	del_timer_sync(&rxnet->peer_keepalive_timer);
	cancel_work_sync(&rxnet->peer_keepalive_work);
	rxrpc_destroy_all_calls(rxnet);
	rxrpc_destroy_all_connections(rxnet);
	rxrpc_destroy_all_peers(rxnet);
	rxrpc_destroy_all_locals(rxnet);
	proc_remove(rxnet->proc_net);
}

struct pernet_operations rxrpc_net_ops = {
	.init	= rxrpc_init_net,
	.exit	= rxrpc_exit_net,
	.id	= &rxrpc_net_id,
	.size	= sizeof(struct rxrpc_net),
};
Commit	Line	Data
b4d0d230	1	// SPDX-License-Identifier: GPL-2.0-or-later
2baec2c3 DH	2	/* rxrpc network namespace handling.
	3	*
	4	* Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
2baec2c3 DH	6	*/
	7
	8	#include <linux/proc_fs.h>
	9	#include "ar-internal.h"
	10
	11	unsigned int rxrpc_net_id;
	12
3d18cbb7 DH	13	static void rxrpc_client_conn_reap_timeout(struct timer_list *timer)
	14	{
	15	struct rxrpc_net *rxnet =
	16	container_of(timer, struct rxrpc_net, client_conn_reap_timer);
	17
	18	if (rxnet->live)
	19	rxrpc_queue_work(&rxnet->client_conn_reaper);
	20	}
	21
	22	static void rxrpc_service_conn_reap_timeout(struct timer_list *timer)
	23	{
	24	struct rxrpc_net *rxnet =
	25	container_of(timer, struct rxrpc_net, service_conn_reap_timer);
	26
	27	if (rxnet->live)
	28	rxrpc_queue_work(&rxnet->service_conn_reaper);
	29	}
	30
ace45bec DH	31	static void rxrpc_peer_keepalive_timeout(struct timer_list *timer)
	32	{
	33	struct rxrpc_net *rxnet =
	34	container_of(timer, struct rxrpc_net, peer_keepalive_timer);
	35
	36	if (rxnet->live)
	37	rxrpc_queue_work(&rxnet->peer_keepalive_work);
	38	}
	39
2baec2c3 DH	40	/*
	41	* Initialise a per-network namespace record.
	42	*/
	43	static __net_init int rxrpc_init_net(struct net *net)
	44	{
	45	struct rxrpc_net *rxnet = rxrpc_net(net);
ace45bec	46	int ret, i;
2baec2c3	47
f859ab61	48	rxnet->live = true;
2baec2c3 DH	49	get_random_bytes(&rxnet->epoch, sizeof(rxnet->epoch));
	50	rxnet->epoch \|= RXRPC_RANDOM_EPOCH;
	51
	52	INIT_LIST_HEAD(&rxnet->calls);
	53	rwlock_init(&rxnet->call_lock);
d3be4d24	54	atomic_set(&rxnet->nr_calls, 1);
2baec2c3	55
31f5f9a1	56	atomic_set(&rxnet->nr_conns, 1);
2baec2c3 DH	57	INIT_LIST_HEAD(&rxnet->conn_proc_list);
	58	INIT_LIST_HEAD(&rxnet->service_conns);
	59	rwlock_init(&rxnet->conn_lock);
3d18cbb7 DH	60	INIT_WORK(&rxnet->service_conn_reaper,
	61	rxrpc_service_connection_reaper);
	62	timer_setup(&rxnet->service_conn_reap_timer,
	63	rxrpc_service_conn_reap_timeout, 0);
2baec2c3 DH	64
	65	rxnet->nr_client_conns = 0;
	66	rxnet->nr_active_client_conns = 0;
	67	rxnet->kill_all_client_conns = false;
	68	spin_lock_init(&rxnet->client_conn_cache_lock);
	69	spin_lock_init(&rxnet->client_conn_discard_lock);
	70	INIT_LIST_HEAD(&rxnet->waiting_client_conns);
	71	INIT_LIST_HEAD(&rxnet->active_client_conns);
	72	INIT_LIST_HEAD(&rxnet->idle_client_conns);
3d18cbb7 DH	73	INIT_WORK(&rxnet->client_conn_reaper,
	74	rxrpc_discard_expired_client_conns);
	75	timer_setup(&rxnet->client_conn_reap_timer,
	76	rxrpc_client_conn_reap_timeout, 0);
2baec2c3 DH	77
	78	INIT_LIST_HEAD(&rxnet->local_endpoints);
	79	mutex_init(&rxnet->local_mutex);
ace45bec	80
2baec2c3 DH	81	hash_init(rxnet->peer_hash);
2baec2c3 DH	82	spin_lock_init(&rxnet->peer_hash_lock);
ace45bec	83	for (i = 0; i < ARRAY_SIZE(rxnet->peer_keepalive); i++)
330bdcfa DH	84	INIT_LIST_HEAD(&rxnet->peer_keepalive[i]);
330bdcfa DH	85	INIT_LIST_HEAD(&rxnet->peer_keepalive_new);
ace45bec DH	86	timer_setup(&rxnet->peer_keepalive_timer,
	87	rxrpc_peer_keepalive_timeout, 0);
	88	INIT_WORK(&rxnet->peer_keepalive_work, rxrpc_peer_keepalive_worker);
330bdcfa	89	rxnet->peer_keepalive_base = ktime_get_seconds();
2baec2c3 DH	90
	91	ret = -ENOMEM;
	92	rxnet->proc_net = proc_net_mkdir(net, "rxrpc", net->proc_net);
	93	if (!rxnet->proc_net)
	94	goto err_proc;
	95
c3506372 CH	96	proc_create_net("calls", 0444, rxnet->proc_net, &rxrpc_call_seq_ops,
	97	sizeof(struct seq_net_private));
	98	proc_create_net("conns", 0444, rxnet->proc_net,
	99	&rxrpc_connection_seq_ops,
	100	sizeof(struct seq_net_private));
bc0e7cf4 DH	101	proc_create_net("peers", 0444, rxnet->proc_net,
	102	&rxrpc_peer_seq_ops,
	103	sizeof(struct seq_net_private));
2baec2c3 DH	104	return 0;
2baec2c3 DH	105
2baec2c3	106	err_proc:
f859ab61	107	rxnet->live = false;
2baec2c3 DH	108	return ret;
	109	}
	110
	111	/*
	112	* Clean up a per-network namespace record.
	113	*/
	114	static __net_exit void rxrpc_exit_net(struct net *net)
	115	{
	116	struct rxrpc_net *rxnet = rxrpc_net(net);
	117
f859ab61	118	rxnet->live = false;
ace45bec DH	119	del_timer_sync(&rxnet->peer_keepalive_timer);
ace45bec DH	120	cancel_work_sync(&rxnet->peer_keepalive_work);
2baec2c3 DH	121	rxrpc_destroy_all_calls(rxnet);
2baec2c3 DH	122	rxrpc_destroy_all_connections(rxnet);
17226f12	123	rxrpc_destroy_all_peers(rxnet);
2baec2c3 DH	124	rxrpc_destroy_all_locals(rxnet);
	125	proc_remove(rxnet->proc_net);
	126	}
	127
	128	struct pernet_operations rxrpc_net_ops = {
	129	.init = rxrpc_init_net,
	130	.exit = rxrpc_exit_net,
	131	.id = &rxrpc_net_id,
	132	.size = sizeof(struct rxrpc_net),
	133	};