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