Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* net/atm/proc.c - ATM /proc interface |
3 | * | |
4 | * Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA | |
5 | * | |
6 | * seq_file api usage by romieu@fr.zoreil.com | |
7 | * | |
8 | * Evaluating the efficiency of the whole thing if left as an exercise to | |
9 | * the reader. | |
10 | */ | |
11 | ||
1da177e4 LT |
12 | #include <linux/module.h> /* for EXPORT_SYMBOL */ |
13 | #include <linux/string.h> | |
14 | #include <linux/types.h> | |
15 | #include <linux/mm.h> | |
16 | #include <linux/fs.h> | |
17 | #include <linux/stat.h> | |
18 | #include <linux/proc_fs.h> | |
19 | #include <linux/seq_file.h> | |
20 | #include <linux/errno.h> | |
21 | #include <linux/atm.h> | |
22 | #include <linux/atmdev.h> | |
23 | #include <linux/netdevice.h> | |
24 | #include <linux/atmclip.h> | |
25 | #include <linux/init.h> /* for __init */ | |
5a0e3ad6 | 26 | #include <linux/slab.h> |
457c4cbc | 27 | #include <net/net_namespace.h> |
1da177e4 | 28 | #include <net/atmclip.h> |
07367adb JP |
29 | #include <linux/uaccess.h> |
30 | #include <linux/param.h> /* for HZ */ | |
60063497 | 31 | #include <linux/atomic.h> |
1da177e4 LT |
32 | #include "resources.h" |
33 | #include "common.h" /* atm_proc_init prototype */ | |
34 | #include "signaling.h" /* to get sigd - ugly too */ | |
35 | ||
07367adb JP |
36 | static ssize_t proc_dev_atm_read(struct file *file, char __user *buf, |
37 | size_t count, loff_t *pos); | |
1da177e4 | 38 | |
9a32144e | 39 | static const struct file_operations proc_atm_dev_ops = { |
1da177e4 | 40 | .read = proc_dev_atm_read, |
6038f373 | 41 | .llseek = noop_llseek, |
1da177e4 LT |
42 | }; |
43 | ||
44 | static void add_stats(struct seq_file *seq, const char *aal, | |
45 | const struct k_atm_aal_stats *stats) | |
46 | { | |
47 | seq_printf(seq, "%s ( %d %d %d %d %d )", aal, | |
07367adb JP |
48 | atomic_read(&stats->tx), atomic_read(&stats->tx_err), |
49 | atomic_read(&stats->rx), atomic_read(&stats->rx_err), | |
50 | atomic_read(&stats->rx_drop)); | |
1da177e4 LT |
51 | } |
52 | ||
53 | static void atm_dev_info(struct seq_file *seq, const struct atm_dev *dev) | |
54 | { | |
55 | int i; | |
56 | ||
57 | seq_printf(seq, "%3d %-8s", dev->number, dev->type); | |
58 | for (i = 0; i < ESI_LEN; i++) | |
59 | seq_printf(seq, "%02x", dev->esi[i]); | |
60 | seq_puts(seq, " "); | |
61 | add_stats(seq, "0", &dev->stats.aal0); | |
62 | seq_puts(seq, " "); | |
63 | add_stats(seq, "5", &dev->stats.aal5); | |
458bc30c | 64 | seq_printf(seq, "\t[%d]", refcount_read(&dev->refcnt)); |
1da177e4 LT |
65 | seq_putc(seq, '\n'); |
66 | } | |
67 | ||
68 | struct vcc_state { | |
69 | int bucket; | |
70 | struct sock *sk; | |
1da177e4 LT |
71 | }; |
72 | ||
73 | static inline int compare_family(struct sock *sk, int family) | |
74 | { | |
75 | return !family || (sk->sk_family == family); | |
76 | } | |
77 | ||
78 | static int __vcc_walk(struct sock **sock, int family, int *bucket, loff_t l) | |
79 | { | |
80 | struct sock *sk = *sock; | |
81 | ||
2e1e9848 | 82 | if (sk == SEQ_START_TOKEN) { |
1da177e4 LT |
83 | for (*bucket = 0; *bucket < VCC_HTABLE_SIZE; ++*bucket) { |
84 | struct hlist_head *head = &vcc_hash[*bucket]; | |
85 | ||
86 | sk = hlist_empty(head) ? NULL : __sk_head(head); | |
87 | if (sk) | |
88 | break; | |
89 | } | |
90 | l--; | |
f7d57453 | 91 | } |
1da177e4 LT |
92 | try_again: |
93 | for (; sk; sk = sk_next(sk)) { | |
94 | l -= compare_family(sk, family); | |
95 | if (l < 0) | |
96 | goto out; | |
97 | } | |
98 | if (!sk && ++*bucket < VCC_HTABLE_SIZE) { | |
99 | sk = sk_head(&vcc_hash[*bucket]); | |
100 | goto try_again; | |
101 | } | |
2e1e9848 | 102 | sk = SEQ_START_TOKEN; |
1da177e4 LT |
103 | out: |
104 | *sock = sk; | |
105 | return (l < 0); | |
106 | } | |
107 | ||
a2d03aac | 108 | static inline void *vcc_walk(struct seq_file *seq, loff_t l) |
1da177e4 | 109 | { |
a2d03aac CH |
110 | struct vcc_state *state = seq->private; |
111 | int family = (uintptr_t)(PDE_DATA(file_inode(seq->file))); | |
1da177e4 | 112 | |
a2d03aac CH |
113 | return __vcc_walk(&state->sk, family, &state->bucket, l) ? |
114 | state : NULL; | |
1da177e4 LT |
115 | } |
116 | ||
117 | static void *vcc_seq_start(struct seq_file *seq, loff_t *pos) | |
5c17d5f1 | 118 | __acquires(vcc_sklist_lock) |
1da177e4 LT |
119 | { |
120 | struct vcc_state *state = seq->private; | |
121 | loff_t left = *pos; | |
122 | ||
123 | read_lock(&vcc_sklist_lock); | |
2e1e9848 | 124 | state->sk = SEQ_START_TOKEN; |
a2d03aac | 125 | return left ? vcc_walk(seq, left) : SEQ_START_TOKEN; |
1da177e4 LT |
126 | } |
127 | ||
128 | static void vcc_seq_stop(struct seq_file *seq, void *v) | |
5c17d5f1 | 129 | __releases(vcc_sklist_lock) |
1da177e4 LT |
130 | { |
131 | read_unlock(&vcc_sklist_lock); | |
132 | } | |
133 | ||
134 | static void *vcc_seq_next(struct seq_file *seq, void *v, loff_t *pos) | |
135 | { | |
a2d03aac | 136 | v = vcc_walk(seq, 1); |
d0edde8d DC |
137 | if (v) |
138 | (*pos)++; | |
1da177e4 LT |
139 | return v; |
140 | } | |
141 | ||
142 | static void pvc_info(struct seq_file *seq, struct atm_vcc *vcc) | |
143 | { | |
07367adb JP |
144 | static const char *const class_name[] = { |
145 | "off", "UBR", "CBR", "VBR", "ABR"}; | |
36cbd3dc | 146 | static const char *const aal_name[] = { |
1da177e4 LT |
147 | "---", "1", "2", "3/4", /* 0- 3 */ |
148 | "???", "5", "???", "???", /* 4- 7 */ | |
149 | "???", "???", "???", "???", /* 8-11 */ | |
150 | "???", "0", "???", "???"}; /* 12-15 */ | |
151 | ||
152 | seq_printf(seq, "%3d %3d %5d %-3s %7d %-5s %7d %-6s", | |
07367adb JP |
153 | vcc->dev->number, vcc->vpi, vcc->vci, |
154 | vcc->qos.aal >= ARRAY_SIZE(aal_name) ? "err" : | |
155 | aal_name[vcc->qos.aal], vcc->qos.rxtp.min_pcr, | |
156 | class_name[vcc->qos.rxtp.traffic_class], | |
157 | vcc->qos.txtp.min_pcr, | |
158 | class_name[vcc->qos.txtp.traffic_class]); | |
1da177e4 LT |
159 | if (test_bit(ATM_VF_IS_CLIP, &vcc->flags)) { |
160 | struct clip_vcc *clip_vcc = CLIP_VCC(vcc); | |
161 | struct net_device *dev; | |
162 | ||
163 | dev = clip_vcc->entry ? clip_vcc->entry->neigh->dev : NULL; | |
164 | seq_printf(seq, "CLIP, Itf:%s, Encap:", | |
165 | dev ? dev->name : "none?"); | |
166 | seq_printf(seq, "%s", clip_vcc->encap ? "LLC/SNAP" : "None"); | |
167 | } | |
168 | seq_putc(seq, '\n'); | |
169 | } | |
170 | ||
171 | static const char *vcc_state(struct atm_vcc *vcc) | |
172 | { | |
36cbd3dc | 173 | static const char *const map[] = { ATM_VS2TXT_MAP }; |
1da177e4 LT |
174 | |
175 | return map[ATM_VF2VS(vcc->flags)]; | |
176 | } | |
177 | ||
178 | static void vcc_info(struct seq_file *seq, struct atm_vcc *vcc) | |
179 | { | |
180 | struct sock *sk = sk_atm(vcc); | |
181 | ||
71338aa7 | 182 | seq_printf(seq, "%pK ", vcc); |
1da177e4 LT |
183 | if (!vcc->dev) |
184 | seq_printf(seq, "Unassigned "); | |
f7d57453 | 185 | else |
1da177e4 LT |
186 | seq_printf(seq, "%3d %3d %5d ", vcc->dev->number, vcc->vpi, |
187 | vcc->vci); | |
188 | switch (sk->sk_family) { | |
07367adb JP |
189 | case AF_ATMPVC: |
190 | seq_printf(seq, "PVC"); | |
191 | break; | |
192 | case AF_ATMSVC: | |
193 | seq_printf(seq, "SVC"); | |
194 | break; | |
195 | default: | |
196 | seq_printf(seq, "%3d", sk->sk_family); | |
1da177e4 | 197 | } |
07367adb JP |
198 | seq_printf(seq, " %04lx %5d %7d/%7d %7d/%7d [%d]\n", |
199 | vcc->flags, sk->sk_err, | |
200 | sk_wmem_alloc_get(sk), sk->sk_sndbuf, | |
201 | sk_rmem_alloc_get(sk), sk->sk_rcvbuf, | |
41c6d650 | 202 | refcount_read(&sk->sk_refcnt)); |
1da177e4 LT |
203 | } |
204 | ||
205 | static void svc_info(struct seq_file *seq, struct atm_vcc *vcc) | |
206 | { | |
207 | if (!vcc->dev) | |
208 | seq_printf(seq, sizeof(void *) == 4 ? | |
71338aa7 | 209 | "N/A@%pK%10s" : "N/A@%pK%2s", vcc, ""); |
1da177e4 LT |
210 | else |
211 | seq_printf(seq, "%3d %3d %5d ", | |
212 | vcc->dev->number, vcc->vpi, vcc->vci); | |
213 | seq_printf(seq, "%-10s ", vcc_state(vcc)); | |
214 | seq_printf(seq, "%s%s", vcc->remote.sas_addr.pub, | |
215 | *vcc->remote.sas_addr.pub && *vcc->remote.sas_addr.prv ? "+" : ""); | |
216 | if (*vcc->remote.sas_addr.prv) { | |
217 | int i; | |
218 | ||
219 | for (i = 0; i < ATM_ESA_LEN; i++) | |
220 | seq_printf(seq, "%02x", vcc->remote.sas_addr.prv[i]); | |
221 | } | |
222 | seq_putc(seq, '\n'); | |
223 | } | |
224 | ||
225 | static int atm_dev_seq_show(struct seq_file *seq, void *v) | |
226 | { | |
227 | static char atm_dev_banner[] = | |
228 | "Itf Type ESI/\"MAC\"addr " | |
229 | "AAL(TX,err,RX,err,drop) ... [refcnt]\n"; | |
f7d57453 | 230 | |
67de7924 | 231 | if (v == &atm_devs) |
1da177e4 LT |
232 | seq_puts(seq, atm_dev_banner); |
233 | else { | |
234 | struct atm_dev *dev = list_entry(v, struct atm_dev, dev_list); | |
235 | ||
236 | atm_dev_info(seq, dev); | |
237 | } | |
f7d57453 | 238 | return 0; |
1da177e4 | 239 | } |
f7d57453 | 240 | |
56b3d975 | 241 | static const struct seq_operations atm_dev_seq_ops = { |
1da177e4 LT |
242 | .start = atm_dev_seq_start, |
243 | .next = atm_dev_seq_next, | |
244 | .stop = atm_dev_seq_stop, | |
245 | .show = atm_dev_seq_show, | |
246 | }; | |
f7d57453 | 247 | |
1da177e4 LT |
248 | static int pvc_seq_show(struct seq_file *seq, void *v) |
249 | { | |
f7d57453 | 250 | static char atm_pvc_banner[] = |
1da177e4 LT |
251 | "Itf VPI VCI AAL RX(PCR,Class) TX(PCR,Class)\n"; |
252 | ||
2e1e9848 | 253 | if (v == SEQ_START_TOKEN) |
1da177e4 LT |
254 | seq_puts(seq, atm_pvc_banner); |
255 | else { | |
256 | struct vcc_state *state = seq->private; | |
257 | struct atm_vcc *vcc = atm_sk(state->sk); | |
258 | ||
259 | pvc_info(seq, vcc); | |
260 | } | |
261 | return 0; | |
262 | } | |
263 | ||
56b3d975 | 264 | static const struct seq_operations pvc_seq_ops = { |
1da177e4 LT |
265 | .start = vcc_seq_start, |
266 | .next = vcc_seq_next, | |
267 | .stop = vcc_seq_stop, | |
268 | .show = pvc_seq_show, | |
269 | }; | |
270 | ||
1da177e4 LT |
271 | static int vcc_seq_show(struct seq_file *seq, void *v) |
272 | { | |
2e1e9848 | 273 | if (v == SEQ_START_TOKEN) { |
f7d57453 YH |
274 | seq_printf(seq, sizeof(void *) == 4 ? "%-8s%s" : "%-16s%s", |
275 | "Address ", "Itf VPI VCI Fam Flags Reply " | |
276 | "Send buffer Recv buffer [refcnt]\n"); | |
277 | } else { | |
278 | struct vcc_state *state = seq->private; | |
279 | struct atm_vcc *vcc = atm_sk(state->sk); | |
280 | ||
281 | vcc_info(seq, vcc); | |
282 | } | |
283 | return 0; | |
1da177e4 | 284 | } |
f7d57453 | 285 | |
56b3d975 | 286 | static const struct seq_operations vcc_seq_ops = { |
f7d57453 YH |
287 | .start = vcc_seq_start, |
288 | .next = vcc_seq_next, | |
289 | .stop = vcc_seq_stop, | |
290 | .show = vcc_seq_show, | |
1da177e4 | 291 | }; |
f7d57453 | 292 | |
1da177e4 LT |
293 | static int svc_seq_show(struct seq_file *seq, void *v) |
294 | { | |
36cbd3dc | 295 | static const char atm_svc_banner[] = |
1da177e4 LT |
296 | "Itf VPI VCI State Remote\n"; |
297 | ||
2e1e9848 | 298 | if (v == SEQ_START_TOKEN) |
1da177e4 LT |
299 | seq_puts(seq, atm_svc_banner); |
300 | else { | |
301 | struct vcc_state *state = seq->private; | |
302 | struct atm_vcc *vcc = atm_sk(state->sk); | |
303 | ||
304 | svc_info(seq, vcc); | |
305 | } | |
306 | return 0; | |
307 | } | |
308 | ||
56b3d975 | 309 | static const struct seq_operations svc_seq_ops = { |
1da177e4 LT |
310 | .start = vcc_seq_start, |
311 | .next = vcc_seq_next, | |
312 | .stop = vcc_seq_stop, | |
313 | .show = svc_seq_show, | |
314 | }; | |
315 | ||
1da177e4 LT |
316 | static ssize_t proc_dev_atm_read(struct file *file, char __user *buf, |
317 | size_t count, loff_t *pos) | |
318 | { | |
319 | struct atm_dev *dev; | |
320 | unsigned long page; | |
321 | int length; | |
322 | ||
07367adb JP |
323 | if (count == 0) |
324 | return 0; | |
1da177e4 | 325 | page = get_zeroed_page(GFP_KERNEL); |
07367adb JP |
326 | if (!page) |
327 | return -ENOMEM; | |
d9dda78b | 328 | dev = PDE_DATA(file_inode(file)); |
1da177e4 LT |
329 | if (!dev->ops->proc_read) |
330 | length = -EINVAL; | |
331 | else { | |
07367adb JP |
332 | length = dev->ops->proc_read(dev, pos, (char *)page); |
333 | if (length > count) | |
334 | length = -EINVAL; | |
1da177e4 LT |
335 | } |
336 | if (length >= 0) { | |
07367adb JP |
337 | if (copy_to_user(buf, (char *)page, length)) |
338 | length = -EFAULT; | |
1da177e4 LT |
339 | (*pos)++; |
340 | } | |
341 | free_page(page); | |
342 | return length; | |
343 | } | |
344 | ||
1da177e4 LT |
345 | struct proc_dir_entry *atm_proc_root; |
346 | EXPORT_SYMBOL(atm_proc_root); | |
347 | ||
348 | ||
349 | int atm_proc_dev_register(struct atm_dev *dev) | |
350 | { | |
1da177e4 LT |
351 | int error; |
352 | ||
353 | /* No proc info */ | |
354 | if (!dev->ops->proc_read) | |
355 | return 0; | |
356 | ||
357 | error = -ENOMEM; | |
62c97ac0 | 358 | dev->proc_name = kasprintf(GFP_KERNEL, "%s:%d", dev->type, dev->number); |
1da177e4 LT |
359 | if (!dev->proc_name) |
360 | goto err_out; | |
1da177e4 | 361 | |
0c89652a DL |
362 | dev->proc_entry = proc_create_data(dev->proc_name, 0, atm_proc_root, |
363 | &proc_atm_dev_ops, dev); | |
1da177e4 LT |
364 | if (!dev->proc_entry) |
365 | goto err_free_name; | |
1da177e4 | 366 | return 0; |
07367adb | 367 | |
1da177e4 LT |
368 | err_free_name: |
369 | kfree(dev->proc_name); | |
370 | err_out: | |
371 | return error; | |
372 | } | |
373 | ||
1da177e4 LT |
374 | void atm_proc_dev_deregister(struct atm_dev *dev) |
375 | { | |
376 | if (!dev->ops->proc_read) | |
377 | return; | |
378 | ||
379 | remove_proc_entry(dev->proc_name, atm_proc_root); | |
380 | kfree(dev->proc_name); | |
381 | } | |
382 | ||
1da177e4 LT |
383 | int __init atm_proc_init(void) |
384 | { | |
e5d69b9f | 385 | atm_proc_root = proc_net_mkdir(&init_net, "atm", init_net.proc_net); |
1da177e4 | 386 | if (!atm_proc_root) |
ce9fe438 CH |
387 | return -ENOMEM; |
388 | proc_create_seq("devices", 0444, atm_proc_root, &atm_dev_seq_ops); | |
a2d03aac CH |
389 | proc_create_seq_private("pvc", 0444, atm_proc_root, &pvc_seq_ops, |
390 | sizeof(struct vcc_state), (void *)(uintptr_t)PF_ATMPVC); | |
391 | proc_create_seq_private("svc", 0444, atm_proc_root, &svc_seq_ops, | |
392 | sizeof(struct vcc_state), (void *)(uintptr_t)PF_ATMSVC); | |
393 | proc_create_seq_private("vc", 0444, atm_proc_root, &vcc_seq_ops, | |
394 | sizeof(struct vcc_state), NULL); | |
ce9fe438 | 395 | return 0; |
1da177e4 LT |
396 | } |
397 | ||
b9c6e3e9 | 398 | void atm_proc_exit(void) |
1da177e4 | 399 | { |
ce9fe438 | 400 | remove_proc_subtree("atm", init_net.proc_net); |
1da177e4 | 401 | } |