root/net/appletalk/atalk_proc.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. atalk_get_interface_idx
  2. atalk_seq_interface_start
  3. atalk_seq_interface_next
  4. atalk_seq_interface_stop
  5. atalk_seq_interface_show
  6. atalk_get_route_idx
  7. atalk_seq_route_start
  8. atalk_seq_route_next
  9. atalk_seq_route_stop
  10. atalk_seq_route_show
  11. atalk_seq_socket_start
  12. atalk_seq_socket_next
  13. atalk_seq_socket_stop
  14. atalk_seq_socket_show
  15. atalk_proc_init
  16. atalk_proc_exit

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *      atalk_proc.c - proc support for Appletalk
   4  *
   5  *      Copyright(c) Arnaldo Carvalho de Melo <acme@conectiva.com.br>
   6  */
   7 
   8 #include <linux/init.h>
   9 #include <linux/proc_fs.h>
  10 #include <linux/seq_file.h>
  11 #include <net/net_namespace.h>
  12 #include <net/sock.h>
  13 #include <linux/atalk.h>
  14 #include <linux/export.h>
  15 
  16 
  17 static __inline__ struct atalk_iface *atalk_get_interface_idx(loff_t pos)
  18 {
  19         struct atalk_iface *i;
  20 
  21         for (i = atalk_interfaces; pos && i; i = i->next)
  22                 --pos;
  23 
  24         return i;
  25 }
  26 
  27 static void *atalk_seq_interface_start(struct seq_file *seq, loff_t *pos)
  28         __acquires(atalk_interfaces_lock)
  29 {
  30         loff_t l = *pos;
  31 
  32         read_lock_bh(&atalk_interfaces_lock);
  33         return l ? atalk_get_interface_idx(--l) : SEQ_START_TOKEN;
  34 }
  35 
  36 static void *atalk_seq_interface_next(struct seq_file *seq, void *v, loff_t *pos)
  37 {
  38         struct atalk_iface *i;
  39 
  40         ++*pos;
  41         if (v == SEQ_START_TOKEN) {
  42                 i = NULL;
  43                 if (atalk_interfaces)
  44                         i = atalk_interfaces;
  45                 goto out;
  46         }
  47         i = v;
  48         i = i->next;
  49 out:
  50         return i;
  51 }
  52 
  53 static void atalk_seq_interface_stop(struct seq_file *seq, void *v)
  54         __releases(atalk_interfaces_lock)
  55 {
  56         read_unlock_bh(&atalk_interfaces_lock);
  57 }
  58 
  59 static int atalk_seq_interface_show(struct seq_file *seq, void *v)
  60 {
  61         struct atalk_iface *iface;
  62 
  63         if (v == SEQ_START_TOKEN) {
  64                 seq_puts(seq, "Interface        Address   Networks  "
  65                               "Status\n");
  66                 goto out;
  67         }
  68 
  69         iface = v;
  70         seq_printf(seq, "%-16s %04X:%02X  %04X-%04X  %d\n",
  71                    iface->dev->name, ntohs(iface->address.s_net),
  72                    iface->address.s_node, ntohs(iface->nets.nr_firstnet),
  73                    ntohs(iface->nets.nr_lastnet), iface->status);
  74 out:
  75         return 0;
  76 }
  77 
  78 static __inline__ struct atalk_route *atalk_get_route_idx(loff_t pos)
  79 {
  80         struct atalk_route *r;
  81 
  82         for (r = atalk_routes; pos && r; r = r->next)
  83                 --pos;
  84 
  85         return r;
  86 }
  87 
  88 static void *atalk_seq_route_start(struct seq_file *seq, loff_t *pos)
  89         __acquires(atalk_routes_lock)
  90 {
  91         loff_t l = *pos;
  92 
  93         read_lock_bh(&atalk_routes_lock);
  94         return l ? atalk_get_route_idx(--l) : SEQ_START_TOKEN;
  95 }
  96 
  97 static void *atalk_seq_route_next(struct seq_file *seq, void *v, loff_t *pos)
  98 {
  99         struct atalk_route *r;
 100 
 101         ++*pos;
 102         if (v == SEQ_START_TOKEN) {
 103                 r = NULL;
 104                 if (atalk_routes)
 105                         r = atalk_routes;
 106                 goto out;
 107         }
 108         r = v;
 109         r = r->next;
 110 out:
 111         return r;
 112 }
 113 
 114 static void atalk_seq_route_stop(struct seq_file *seq, void *v)
 115         __releases(atalk_routes_lock)
 116 {
 117         read_unlock_bh(&atalk_routes_lock);
 118 }
 119 
 120 static int atalk_seq_route_show(struct seq_file *seq, void *v)
 121 {
 122         struct atalk_route *rt;
 123 
 124         if (v == SEQ_START_TOKEN) {
 125                 seq_puts(seq, "Target        Router  Flags Dev\n");
 126                 goto out;
 127         }
 128 
 129         if (atrtr_default.dev) {
 130                 rt = &atrtr_default;
 131                 seq_printf(seq, "Default     %04X:%02X  %-4d  %s\n",
 132                                ntohs(rt->gateway.s_net), rt->gateway.s_node,
 133                                rt->flags, rt->dev->name);
 134         }
 135 
 136         rt = v;
 137         seq_printf(seq, "%04X:%02X     %04X:%02X  %-4d  %s\n",
 138                    ntohs(rt->target.s_net), rt->target.s_node,
 139                    ntohs(rt->gateway.s_net), rt->gateway.s_node,
 140                    rt->flags, rt->dev->name);
 141 out:
 142         return 0;
 143 }
 144 
 145 static void *atalk_seq_socket_start(struct seq_file *seq, loff_t *pos)
 146         __acquires(atalk_sockets_lock)
 147 {
 148         read_lock_bh(&atalk_sockets_lock);
 149         return seq_hlist_start_head(&atalk_sockets, *pos);
 150 }
 151 
 152 static void *atalk_seq_socket_next(struct seq_file *seq, void *v, loff_t *pos)
 153 {
 154         return seq_hlist_next(v, &atalk_sockets, pos);
 155 }
 156 
 157 static void atalk_seq_socket_stop(struct seq_file *seq, void *v)
 158         __releases(atalk_sockets_lock)
 159 {
 160         read_unlock_bh(&atalk_sockets_lock);
 161 }
 162 
 163 static int atalk_seq_socket_show(struct seq_file *seq, void *v)
 164 {
 165         struct sock *s;
 166         struct atalk_sock *at;
 167 
 168         if (v == SEQ_START_TOKEN) {
 169                 seq_printf(seq, "Type Local_addr  Remote_addr Tx_queue "
 170                                 "Rx_queue St UID\n");
 171                 goto out;
 172         }
 173 
 174         s = sk_entry(v);
 175         at = at_sk(s);
 176 
 177         seq_printf(seq, "%02X   %04X:%02X:%02X  %04X:%02X:%02X  %08X:%08X "
 178                         "%02X %u\n",
 179                    s->sk_type, ntohs(at->src_net), at->src_node, at->src_port,
 180                    ntohs(at->dest_net), at->dest_node, at->dest_port,
 181                    sk_wmem_alloc_get(s),
 182                    sk_rmem_alloc_get(s),
 183                    s->sk_state,
 184                    from_kuid_munged(seq_user_ns(seq), sock_i_uid(s)));
 185 out:
 186         return 0;
 187 }
 188 
 189 static const struct seq_operations atalk_seq_interface_ops = {
 190         .start  = atalk_seq_interface_start,
 191         .next   = atalk_seq_interface_next,
 192         .stop   = atalk_seq_interface_stop,
 193         .show   = atalk_seq_interface_show,
 194 };
 195 
 196 static const struct seq_operations atalk_seq_route_ops = {
 197         .start  = atalk_seq_route_start,
 198         .next   = atalk_seq_route_next,
 199         .stop   = atalk_seq_route_stop,
 200         .show   = atalk_seq_route_show,
 201 };
 202 
 203 static const struct seq_operations atalk_seq_socket_ops = {
 204         .start  = atalk_seq_socket_start,
 205         .next   = atalk_seq_socket_next,
 206         .stop   = atalk_seq_socket_stop,
 207         .show   = atalk_seq_socket_show,
 208 };
 209 
 210 int __init atalk_proc_init(void)
 211 {
 212         if (!proc_mkdir("atalk", init_net.proc_net))
 213                 return -ENOMEM;
 214 
 215         if (!proc_create_seq("atalk/interface", 0444, init_net.proc_net,
 216                             &atalk_seq_interface_ops))
 217                 goto out;
 218 
 219         if (!proc_create_seq("atalk/route", 0444, init_net.proc_net,
 220                             &atalk_seq_route_ops))
 221                 goto out;
 222 
 223         if (!proc_create_seq("atalk/socket", 0444, init_net.proc_net,
 224                             &atalk_seq_socket_ops))
 225                 goto out;
 226 
 227         if (!proc_create_seq_private("atalk/arp", 0444, init_net.proc_net,
 228                                      &aarp_seq_ops,
 229                                      sizeof(struct aarp_iter_state), NULL))
 230                 goto out;
 231 
 232 out:
 233         remove_proc_subtree("atalk", init_net.proc_net);
 234         return -ENOMEM;
 235 }
 236 
 237 void atalk_proc_exit(void)
 238 {
 239         remove_proc_subtree("atalk", init_net.proc_net);
 240 }

/* [<][>][^][v][top][bottom][index][help] */