HACK: cardhu: ignore audio
[linux-2.6.git] / net / rxrpc / ar-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[] = {
18         [RXRPC_CONN_UNUSED]             = "Unused  ",
19         [RXRPC_CONN_CLIENT]             = "Client  ",
20         [RXRPC_CONN_SERVER_UNSECURED]   = "SvUnsec ",
21         [RXRPC_CONN_SERVER_CHALLENGING] = "SvChall ",
22         [RXRPC_CONN_SERVER]             = "SvSecure",
23         [RXRPC_CONN_REMOTELY_ABORTED]   = "RmtAbort",
24         [RXRPC_CONN_LOCALLY_ABORTED]    = "LocAbort",
25         [RXRPC_CONN_NETWORK_ERROR]      = "NetError",
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         read_lock(&rxrpc_call_lock);
34         return seq_list_start_head(&rxrpc_calls, *_pos);
35 }
36
37 static void *rxrpc_call_seq_next(struct seq_file *seq, void *v, loff_t *pos)
38 {
39         return seq_list_next(v, &rxrpc_calls, pos);
40 }
41
42 static void rxrpc_call_seq_stop(struct seq_file *seq, void *v)
43 {
44         read_unlock(&rxrpc_call_lock);
45 }
46
47 static int rxrpc_call_seq_show(struct seq_file *seq, void *v)
48 {
49         struct rxrpc_transport *trans;
50         struct rxrpc_call *call;
51         char lbuff[4 + 4 + 4 + 4 + 5 + 1], rbuff[4 + 4 + 4 + 4 + 5 + 1];
52
53         if (v == &rxrpc_calls) {
54                 seq_puts(seq,
55                          "Proto Local                  Remote                "
56                          " SvID ConnID   CallID   End Use State    Abort   "
57                          " UserID\n");
58                 return 0;
59         }
60
61         call = list_entry(v, struct rxrpc_call, link);
62         trans = call->conn->trans;
63
64         sprintf(lbuff, "%pI4:%u",
65                 &trans->local->srx.transport.sin.sin_addr,
66                 ntohs(trans->local->srx.transport.sin.sin_port));
67
68         sprintf(rbuff, "%pI4:%u",
69                 &trans->peer->srx.transport.sin.sin_addr,
70                 ntohs(trans->peer->srx.transport.sin.sin_port));
71
72         seq_printf(seq,
73                    "UDP   %-22.22s %-22.22s %4x %08x %08x %s %3u"
74                    " %-8.8s %08x %lx\n",
75                    lbuff,
76                    rbuff,
77                    ntohs(call->conn->service_id),
78                    ntohl(call->conn->cid),
79                    ntohl(call->call_id),
80                    call->conn->in_clientflag ? "Svc" : "Clt",
81                    atomic_read(&call->usage),
82                    rxrpc_call_states[call->state],
83                    call->abort_code,
84                    call->user_call_ID);
85
86         return 0;
87 }
88
89 static const struct seq_operations rxrpc_call_seq_ops = {
90         .start  = rxrpc_call_seq_start,
91         .next   = rxrpc_call_seq_next,
92         .stop   = rxrpc_call_seq_stop,
93         .show   = rxrpc_call_seq_show,
94 };
95
96 static int rxrpc_call_seq_open(struct inode *inode, struct file *file)
97 {
98         return seq_open(file, &rxrpc_call_seq_ops);
99 }
100
101 const struct file_operations rxrpc_call_seq_fops = {
102         .owner          = THIS_MODULE,
103         .open           = rxrpc_call_seq_open,
104         .read           = seq_read,
105         .llseek         = seq_lseek,
106         .release        = seq_release,
107 };
108
109 /*
110  * generate a list of extant virtual connections in /proc/net/rxrpc_conns
111  */
112 static void *rxrpc_connection_seq_start(struct seq_file *seq, loff_t *_pos)
113 {
114         read_lock(&rxrpc_connection_lock);
115         return seq_list_start_head(&rxrpc_connections, *_pos);
116 }
117
118 static void *rxrpc_connection_seq_next(struct seq_file *seq, void *v,
119                                        loff_t *pos)
120 {
121         return seq_list_next(v, &rxrpc_connections, pos);
122 }
123
124 static void rxrpc_connection_seq_stop(struct seq_file *seq, void *v)
125 {
126         read_unlock(&rxrpc_connection_lock);
127 }
128
129 static int rxrpc_connection_seq_show(struct seq_file *seq, void *v)
130 {
131         struct rxrpc_connection *conn;
132         struct rxrpc_transport *trans;
133         char lbuff[4 + 4 + 4 + 4 + 5 + 1], rbuff[4 + 4 + 4 + 4 + 5 + 1];
134
135         if (v == &rxrpc_connections) {
136                 seq_puts(seq,
137                          "Proto Local                  Remote                "
138                          " SvID ConnID   Calls    End Use State    Key     "
139                          " Serial   ISerial\n"
140                          );
141                 return 0;
142         }
143
144         conn = list_entry(v, struct rxrpc_connection, link);
145         trans = conn->trans;
146
147         sprintf(lbuff, "%pI4:%u",
148                 &trans->local->srx.transport.sin.sin_addr,
149                 ntohs(trans->local->srx.transport.sin.sin_port));
150
151         sprintf(rbuff, "%pI4:%u",
152                 &trans->peer->srx.transport.sin.sin_addr,
153                 ntohs(trans->peer->srx.transport.sin.sin_port));
154
155         seq_printf(seq,
156                    "UDP   %-22.22s %-22.22s %4x %08x %08x %s %3u"
157                    " %s %08x %08x %08x\n",
158                    lbuff,
159                    rbuff,
160                    ntohs(conn->service_id),
161                    ntohl(conn->cid),
162                    conn->call_counter,
163                    conn->in_clientflag ? "Svc" : "Clt",
164                    atomic_read(&conn->usage),
165                    rxrpc_conn_states[conn->state],
166                    key_serial(conn->key),
167                    atomic_read(&conn->serial),
168                    atomic_read(&conn->hi_serial));
169
170         return 0;
171 }
172
173 static const struct seq_operations rxrpc_connection_seq_ops = {
174         .start  = rxrpc_connection_seq_start,
175         .next   = rxrpc_connection_seq_next,
176         .stop   = rxrpc_connection_seq_stop,
177         .show   = rxrpc_connection_seq_show,
178 };
179
180
181 static int rxrpc_connection_seq_open(struct inode *inode, struct file *file)
182 {
183         return seq_open(file, &rxrpc_connection_seq_ops);
184 }
185
186 const struct file_operations rxrpc_connection_seq_fops = {
187         .owner          = THIS_MODULE,
188         .open           = rxrpc_connection_seq_open,
189         .read           = seq_read,
190         .llseek         = seq_lseek,
191         .release        = seq_release,
192 };