GNU Linux-libre 4.14.303-gnu1
[releases.git] / net / rxrpc / proc.c
1 /* /proc/net/ support for AF_RXRPC
2  *
3  * Copyright (C) 2007 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 License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/module.h>
13 #include <net/sock.h>
14 #include <net/af_rxrpc.h>
15 #include "ar-internal.h"
16
17 static const char *const rxrpc_conn_states[RXRPC_CONN__NR_STATES] = {
18         [RXRPC_CONN_UNUSED]                     = "Unused  ",
19         [RXRPC_CONN_CLIENT]                     = "Client  ",
20         [RXRPC_CONN_SERVICE_PREALLOC]           = "SvPrealc",
21         [RXRPC_CONN_SERVICE_UNSECURED]          = "SvUnsec ",
22         [RXRPC_CONN_SERVICE_CHALLENGING]        = "SvChall ",
23         [RXRPC_CONN_SERVICE]                    = "SvSecure",
24         [RXRPC_CONN_REMOTELY_ABORTED]           = "RmtAbort",
25         [RXRPC_CONN_LOCALLY_ABORTED]            = "LocAbort",
26 };
27
28 /*
29  * generate a list of extant and dead calls in /proc/net/rxrpc_calls
30  */
31 static void *rxrpc_call_seq_start(struct seq_file *seq, loff_t *_pos)
32 {
33         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
34
35         rcu_read_lock();
36         read_lock(&rxnet->call_lock);
37         return seq_list_start_head(&rxnet->calls, *_pos);
38 }
39
40 static void *rxrpc_call_seq_next(struct seq_file *seq, void *v, loff_t *pos)
41 {
42         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
43
44         return seq_list_next(v, &rxnet->calls, pos);
45 }
46
47 static void rxrpc_call_seq_stop(struct seq_file *seq, void *v)
48 {
49         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
50
51         read_unlock(&rxnet->call_lock);
52         rcu_read_unlock();
53 }
54
55 static int rxrpc_call_seq_show(struct seq_file *seq, void *v)
56 {
57         struct rxrpc_local *local;
58         struct rxrpc_sock *rx;
59         struct rxrpc_peer *peer;
60         struct rxrpc_call *call;
61         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
62         rxrpc_seq_t tx_hard_ack, rx_hard_ack;
63         char lbuff[50], rbuff[50];
64
65         if (v == &rxnet->calls) {
66                 seq_puts(seq,
67                          "Proto Local                                          "
68                          " Remote                                         "
69                          " SvID ConnID   CallID   End Use State    Abort   "
70                          " UserID\n");
71                 return 0;
72         }
73
74         call = list_entry(v, struct rxrpc_call, link);
75
76         rx = rcu_dereference(call->socket);
77         if (rx) {
78                 local = READ_ONCE(rx->local);
79                 if (local)
80                         sprintf(lbuff, "%pISpc", &local->srx.transport);
81                 else
82                         strcpy(lbuff, "no_local");
83         } else {
84                 strcpy(lbuff, "no_socket");
85         }
86
87         peer = call->peer;
88         if (peer)
89                 sprintf(rbuff, "%pISpc", &peer->srx.transport);
90         else
91                 strcpy(rbuff, "no_connection");
92
93         tx_hard_ack = READ_ONCE(call->tx_hard_ack);
94         rx_hard_ack = READ_ONCE(call->rx_hard_ack);
95         seq_printf(seq,
96                    "UDP   %-47.47s %-47.47s %4x %08x %08x %s %3u"
97                    " %-8.8s %08x %lx %08x %02x %08x %02x\n",
98                    lbuff,
99                    rbuff,
100                    call->service_id,
101                    call->cid,
102                    call->call_id,
103                    rxrpc_is_service_call(call) ? "Svc" : "Clt",
104                    atomic_read(&call->usage),
105                    rxrpc_call_states[call->state],
106                    call->abort_code,
107                    call->user_call_ID,
108                    tx_hard_ack, READ_ONCE(call->tx_top) - tx_hard_ack,
109                    rx_hard_ack, READ_ONCE(call->rx_top) - rx_hard_ack);
110
111         return 0;
112 }
113
114 static const struct seq_operations rxrpc_call_seq_ops = {
115         .start  = rxrpc_call_seq_start,
116         .next   = rxrpc_call_seq_next,
117         .stop   = rxrpc_call_seq_stop,
118         .show   = rxrpc_call_seq_show,
119 };
120
121 static int rxrpc_call_seq_open(struct inode *inode, struct file *file)
122 {
123         return seq_open_net(inode, file, &rxrpc_call_seq_ops,
124                             sizeof(struct seq_net_private));
125 }
126
127 const struct file_operations rxrpc_call_seq_fops = {
128         .owner          = THIS_MODULE,
129         .open           = rxrpc_call_seq_open,
130         .read           = seq_read,
131         .llseek         = seq_lseek,
132         .release        = seq_release,
133 };
134
135 /*
136  * generate a list of extant virtual connections in /proc/net/rxrpc_conns
137  */
138 static void *rxrpc_connection_seq_start(struct seq_file *seq, loff_t *_pos)
139 {
140         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
141
142         read_lock(&rxnet->conn_lock);
143         return seq_list_start_head(&rxnet->conn_proc_list, *_pos);
144 }
145
146 static void *rxrpc_connection_seq_next(struct seq_file *seq, void *v,
147                                        loff_t *pos)
148 {
149         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
150
151         return seq_list_next(v, &rxnet->conn_proc_list, pos);
152 }
153
154 static void rxrpc_connection_seq_stop(struct seq_file *seq, void *v)
155 {
156         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
157
158         read_unlock(&rxnet->conn_lock);
159 }
160
161 static int rxrpc_connection_seq_show(struct seq_file *seq, void *v)
162 {
163         struct rxrpc_connection *conn;
164         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
165         char lbuff[50], rbuff[50];
166
167         if (v == &rxnet->conn_proc_list) {
168                 seq_puts(seq,
169                          "Proto Local                                          "
170                          " Remote                                         "
171                          " SvID ConnID   End Use State    Key     "
172                          " Serial   ISerial\n"
173                          );
174                 return 0;
175         }
176
177         conn = list_entry(v, struct rxrpc_connection, proc_link);
178         if (conn->state == RXRPC_CONN_SERVICE_PREALLOC) {
179                 strcpy(lbuff, "no_local");
180                 strcpy(rbuff, "no_connection");
181                 goto print;
182         }
183
184         sprintf(lbuff, "%pISpc", &conn->params.local->srx.transport);
185
186         sprintf(rbuff, "%pISpc", &conn->params.peer->srx.transport);
187 print:
188         seq_printf(seq,
189                    "UDP   %-47.47s %-47.47s %4x %08x %s %3u"
190                    " %s %08x %08x %08x\n",
191                    lbuff,
192                    rbuff,
193                    conn->service_id,
194                    conn->proto.cid,
195                    rxrpc_conn_is_service(conn) ? "Svc" : "Clt",
196                    atomic_read(&conn->usage),
197                    rxrpc_conn_states[conn->state],
198                    key_serial(conn->params.key),
199                    atomic_read(&conn->serial),
200                    conn->hi_serial);
201
202         return 0;
203 }
204
205 static const struct seq_operations rxrpc_connection_seq_ops = {
206         .start  = rxrpc_connection_seq_start,
207         .next   = rxrpc_connection_seq_next,
208         .stop   = rxrpc_connection_seq_stop,
209         .show   = rxrpc_connection_seq_show,
210 };
211
212
213 static int rxrpc_connection_seq_open(struct inode *inode, struct file *file)
214 {
215         return seq_open_net(inode, file, &rxrpc_connection_seq_ops,
216                             sizeof(struct seq_net_private));
217 }
218
219 const struct file_operations rxrpc_connection_seq_fops = {
220         .owner          = THIS_MODULE,
221         .open           = rxrpc_connection_seq_open,
222         .read           = seq_read,
223         .llseek         = seq_lseek,
224         .release        = seq_release,
225 };