root/net/rxrpc/net_ns.c

DEFINITIONS

1. rxrpc_client_conn_reap_timeout
2. rxrpc_service_conn_reap_timeout
3. rxrpc_peer_keepalive_timeout
4. rxrpc_init_net
5. rxrpc_exit_net

   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 
  11 unsigned int rxrpc_net_id;
  12 
  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 
  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 
  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);
  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         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);
  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);
  77 
  78         INIT_LIST_HEAD(&rxnet->local_endpoints);
  79         mutex_init(&rxnet->local_mutex);
  80 
  81         hash_init(rxnet->peer_hash);
  82         spin_lock_init(&rxnet->peer_hash_lock);
  83         for (i = 0; i < ARRAY_SIZE(rxnet->peer_keepalive); i++)
  84                 INIT_LIST_HEAD(&rxnet->peer_keepalive[i]);
  85         INIT_LIST_HEAD(&rxnet->peer_keepalive_new);
  86         timer_setup(&rxnet->peer_keepalive_timer,
  87                     rxrpc_peer_keepalive_timeout, 0);
  88         INIT_WORK(&rxnet->peer_keepalive_work, rxrpc_peer_keepalive_worker);
  89         rxnet->peer_keepalive_base = ktime_get_seconds();
  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 
  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));
 101         proc_create_net("peers", 0444, rxnet->proc_net,
 102                         &rxrpc_peer_seq_ops,
 103                         sizeof(struct seq_net_private));
 104         return 0;
 105 
 106 err_proc:
 107         rxnet->live = false;
 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 
 118         rxnet->live = false;
 119         del_timer_sync(&rxnet->peer_keepalive_timer);
 120         cancel_work_sync(&rxnet->peer_keepalive_work);
 121         rxrpc_destroy_all_calls(rxnet);
 122         rxrpc_destroy_all_connections(rxnet);
 123         rxrpc_destroy_all_peers(rxnet);
 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 };