net/rxrpc/net_ns.c

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