GNU Linux-libre 4.19.211-gnu1
[releases.git] / net / 6lowpan / debugfs.c
1 /* This program is free software; you can redistribute it and/or modify
2  * it under the terms of the GNU General Public License version 2
3  * as published by the Free Software Foundation.
4  *
5  * This program is distributed in the hope that it will be useful,
6  * but WITHOUT ANY WARRANTY; without even the implied warranty of
7  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
8  * GNU General Public License for more details.
9  *
10  * Authors:
11  * (C) 2015 Pengutronix, Alexander Aring <aar@pengutronix.de>
12  * Copyright (c)  2015 Nordic Semiconductor. All Rights Reserved.
13  */
14
15 #include <net/6lowpan.h>
16
17 #include "6lowpan_i.h"
18
19 #define LOWPAN_DEBUGFS_CTX_PFX_NUM_ARGS 8
20
21 static struct dentry *lowpan_debugfs;
22
23 static int lowpan_ctx_flag_active_set(void *data, u64 val)
24 {
25         struct lowpan_iphc_ctx *ctx = data;
26
27         if (val != 0 && val != 1)
28                 return -EINVAL;
29
30         if (val)
31                 set_bit(LOWPAN_IPHC_CTX_FLAG_ACTIVE, &ctx->flags);
32         else
33                 clear_bit(LOWPAN_IPHC_CTX_FLAG_ACTIVE, &ctx->flags);
34
35         return 0;
36 }
37
38 static int lowpan_ctx_flag_active_get(void *data, u64 *val)
39 {
40         *val = lowpan_iphc_ctx_is_active(data);
41         return 0;
42 }
43
44 DEFINE_SIMPLE_ATTRIBUTE(lowpan_ctx_flag_active_fops,
45                         lowpan_ctx_flag_active_get,
46                         lowpan_ctx_flag_active_set, "%llu\n");
47
48 static int lowpan_ctx_flag_c_set(void *data, u64 val)
49 {
50         struct lowpan_iphc_ctx *ctx = data;
51
52         if (val != 0 && val != 1)
53                 return -EINVAL;
54
55         if (val)
56                 set_bit(LOWPAN_IPHC_CTX_FLAG_COMPRESSION, &ctx->flags);
57         else
58                 clear_bit(LOWPAN_IPHC_CTX_FLAG_COMPRESSION, &ctx->flags);
59
60         return 0;
61 }
62
63 static int lowpan_ctx_flag_c_get(void *data, u64 *val)
64 {
65         *val = lowpan_iphc_ctx_is_compression(data);
66         return 0;
67 }
68
69 DEFINE_SIMPLE_ATTRIBUTE(lowpan_ctx_flag_c_fops, lowpan_ctx_flag_c_get,
70                         lowpan_ctx_flag_c_set, "%llu\n");
71
72 static int lowpan_ctx_plen_set(void *data, u64 val)
73 {
74         struct lowpan_iphc_ctx *ctx = data;
75         struct lowpan_iphc_ctx_table *t =
76                 container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
77
78         if (val > 128)
79                 return -EINVAL;
80
81         spin_lock_bh(&t->lock);
82         ctx->plen = val;
83         spin_unlock_bh(&t->lock);
84
85         return 0;
86 }
87
88 static int lowpan_ctx_plen_get(void *data, u64 *val)
89 {
90         struct lowpan_iphc_ctx *ctx = data;
91         struct lowpan_iphc_ctx_table *t =
92                 container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
93
94         spin_lock_bh(&t->lock);
95         *val = ctx->plen;
96         spin_unlock_bh(&t->lock);
97         return 0;
98 }
99
100 DEFINE_SIMPLE_ATTRIBUTE(lowpan_ctx_plen_fops, lowpan_ctx_plen_get,
101                         lowpan_ctx_plen_set, "%llu\n");
102
103 static int lowpan_ctx_pfx_show(struct seq_file *file, void *offset)
104 {
105         struct lowpan_iphc_ctx *ctx = file->private;
106         struct lowpan_iphc_ctx_table *t =
107                 container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
108
109         spin_lock_bh(&t->lock);
110         seq_printf(file, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
111                    be16_to_cpu(ctx->pfx.s6_addr16[0]),
112                    be16_to_cpu(ctx->pfx.s6_addr16[1]),
113                    be16_to_cpu(ctx->pfx.s6_addr16[2]),
114                    be16_to_cpu(ctx->pfx.s6_addr16[3]),
115                    be16_to_cpu(ctx->pfx.s6_addr16[4]),
116                    be16_to_cpu(ctx->pfx.s6_addr16[5]),
117                    be16_to_cpu(ctx->pfx.s6_addr16[6]),
118                    be16_to_cpu(ctx->pfx.s6_addr16[7]));
119         spin_unlock_bh(&t->lock);
120
121         return 0;
122 }
123
124 static int lowpan_ctx_pfx_open(struct inode *inode, struct file *file)
125 {
126         return single_open(file, lowpan_ctx_pfx_show, inode->i_private);
127 }
128
129 static ssize_t lowpan_ctx_pfx_write(struct file *fp,
130                                     const char __user *user_buf, size_t count,
131                                     loff_t *ppos)
132 {
133         char buf[128] = {};
134         struct seq_file *file = fp->private_data;
135         struct lowpan_iphc_ctx *ctx = file->private;
136         struct lowpan_iphc_ctx_table *t =
137                 container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
138         int status = count, n, i;
139         unsigned int addr[8];
140
141         if (copy_from_user(&buf, user_buf, min_t(size_t, sizeof(buf) - 1,
142                                                  count))) {
143                 status = -EFAULT;
144                 goto out;
145         }
146
147         n = sscanf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
148                    &addr[0], &addr[1], &addr[2], &addr[3], &addr[4],
149                    &addr[5], &addr[6], &addr[7]);
150         if (n != LOWPAN_DEBUGFS_CTX_PFX_NUM_ARGS) {
151                 status = -EINVAL;
152                 goto out;
153         }
154
155         spin_lock_bh(&t->lock);
156         for (i = 0; i < 8; i++)
157                 ctx->pfx.s6_addr16[i] = cpu_to_be16(addr[i] & 0xffff);
158         spin_unlock_bh(&t->lock);
159
160 out:
161         return status;
162 }
163
164 static const struct file_operations lowpan_ctx_pfx_fops = {
165         .open           = lowpan_ctx_pfx_open,
166         .read           = seq_read,
167         .write          = lowpan_ctx_pfx_write,
168         .llseek         = seq_lseek,
169         .release        = single_release,
170 };
171
172 static int lowpan_dev_debugfs_ctx_init(struct net_device *dev,
173                                        struct dentry *ctx, u8 id)
174 {
175         struct lowpan_dev *ldev = lowpan_dev(dev);
176         struct dentry *dentry, *root;
177         char buf[32];
178
179         WARN_ON_ONCE(id > LOWPAN_IPHC_CTX_TABLE_SIZE);
180
181         sprintf(buf, "%d", id);
182
183         root = debugfs_create_dir(buf, ctx);
184         if (!root)
185                 return -EINVAL;
186
187         dentry = debugfs_create_file("active", 0644, root,
188                                      &ldev->ctx.table[id],
189                                      &lowpan_ctx_flag_active_fops);
190         if (!dentry)
191                 return -EINVAL;
192
193         dentry = debugfs_create_file("compression", 0644, root,
194                                      &ldev->ctx.table[id],
195                                      &lowpan_ctx_flag_c_fops);
196         if (!dentry)
197                 return -EINVAL;
198
199         dentry = debugfs_create_file("prefix", 0644, root,
200                                      &ldev->ctx.table[id],
201                                      &lowpan_ctx_pfx_fops);
202         if (!dentry)
203                 return -EINVAL;
204
205         dentry = debugfs_create_file("prefix_len", 0644, root,
206                                      &ldev->ctx.table[id],
207                                      &lowpan_ctx_plen_fops);
208         if (!dentry)
209                 return -EINVAL;
210
211         return 0;
212 }
213
214 static int lowpan_context_show(struct seq_file *file, void *offset)
215 {
216         struct lowpan_iphc_ctx_table *t = file->private;
217         int i;
218
219         seq_printf(file, "%3s|%-43s|%c\n", "cid", "prefix", 'C');
220         seq_puts(file, "-------------------------------------------------\n");
221
222         spin_lock_bh(&t->lock);
223         for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++) {
224                 if (!lowpan_iphc_ctx_is_active(&t->table[i]))
225                         continue;
226
227                 seq_printf(file, "%3d|%39pI6c/%-3d|%d\n", t->table[i].id,
228                            &t->table[i].pfx, t->table[i].plen,
229                            lowpan_iphc_ctx_is_compression(&t->table[i]));
230         }
231         spin_unlock_bh(&t->lock);
232
233         return 0;
234 }
235
236 static int lowpan_context_open(struct inode *inode, struct file *file)
237 {
238         return single_open(file, lowpan_context_show, inode->i_private);
239 }
240
241 static const struct file_operations lowpan_context_fops = {
242         .open           = lowpan_context_open,
243         .read           = seq_read,
244         .llseek         = seq_lseek,
245         .release        = single_release,
246 };
247
248 static int lowpan_short_addr_get(void *data, u64 *val)
249 {
250         struct wpan_dev *wdev = data;
251
252         rtnl_lock();
253         *val = le16_to_cpu(wdev->short_addr);
254         rtnl_unlock();
255
256         return 0;
257 }
258
259 DEFINE_SIMPLE_ATTRIBUTE(lowpan_short_addr_fops, lowpan_short_addr_get,
260                         NULL, "0x%04llx\n");
261
262 static int lowpan_dev_debugfs_802154_init(const struct net_device *dev,
263                                           struct lowpan_dev *ldev)
264 {
265         struct dentry *dentry, *root;
266
267         if (!lowpan_is_ll(dev, LOWPAN_LLTYPE_IEEE802154))
268                 return 0;
269
270         root = debugfs_create_dir("ieee802154", ldev->iface_debugfs);
271         if (!root)
272                 return -EINVAL;
273
274         dentry = debugfs_create_file("short_addr", 0444, root,
275                                      lowpan_802154_dev(dev)->wdev->ieee802154_ptr,
276                                      &lowpan_short_addr_fops);
277         if (!dentry)
278                 return -EINVAL;
279
280         return 0;
281 }
282
283 int lowpan_dev_debugfs_init(struct net_device *dev)
284 {
285         struct lowpan_dev *ldev = lowpan_dev(dev);
286         struct dentry *contexts, *dentry;
287         int ret, i;
288
289         /* creating the root */
290         ldev->iface_debugfs = debugfs_create_dir(dev->name, lowpan_debugfs);
291         if (!ldev->iface_debugfs)
292                 goto fail;
293
294         contexts = debugfs_create_dir("contexts", ldev->iface_debugfs);
295         if (!contexts)
296                 goto remove_root;
297
298         dentry = debugfs_create_file("show", 0644, contexts,
299                                      &lowpan_dev(dev)->ctx,
300                                      &lowpan_context_fops);
301         if (!dentry)
302                 goto remove_root;
303
304         for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++) {
305                 ret = lowpan_dev_debugfs_ctx_init(dev, contexts, i);
306                 if (ret < 0)
307                         goto remove_root;
308         }
309
310         ret = lowpan_dev_debugfs_802154_init(dev, ldev);
311         if (ret < 0)
312                 goto remove_root;
313
314         return 0;
315
316 remove_root:
317         lowpan_dev_debugfs_exit(dev);
318 fail:
319         return -EINVAL;
320 }
321
322 void lowpan_dev_debugfs_exit(struct net_device *dev)
323 {
324         debugfs_remove_recursive(lowpan_dev(dev)->iface_debugfs);
325 }
326
327 int __init lowpan_debugfs_init(void)
328 {
329         lowpan_debugfs = debugfs_create_dir("6lowpan", NULL);
330         if (!lowpan_debugfs)
331                 return -EINVAL;
332
333         return 0;
334 }
335
336 void lowpan_debugfs_exit(void)
337 {
338         debugfs_remove_recursive(lowpan_debugfs);
339 }