xref: /freebsd/sys/compat/lindebugfs/lindebugfs.c (revision 867b4decb4d50579152e52c594632cdc0f6266ff)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2016-2018, Matthew Macy <mmacy@freebsd.org>
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  *
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/queue.h>
35 #include <sys/blist.h>
36 #include <sys/conf.h>
37 #include <sys/exec.h>
38 #include <sys/filedesc.h>
39 #include <sys/kernel.h>
40 #include <sys/linker.h>
41 #include <sys/malloc.h>
42 #include <sys/mount.h>
43 #include <sys/mutex.h>
44 #include <sys/proc.h>
45 #include <sys/resourcevar.h>
46 #include <sys/sbuf.h>
47 #include <sys/smp.h>
48 #include <sys/socket.h>
49 #include <sys/vnode.h>
50 #include <sys/bus.h>
51 #include <sys/pciio.h>
52 
53 #include <dev/pci/pcivar.h>
54 #include <dev/pci/pcireg.h>
55 
56 #include <net/if.h>
57 
58 #include <vm/vm.h>
59 #include <vm/pmap.h>
60 #include <vm/vm_map.h>
61 #include <vm/vm_param.h>
62 #include <vm/vm_object.h>
63 #include <vm/swap_pager.h>
64 
65 #include <machine/bus.h>
66 
67 #include <compat/linux/linux_ioctl.h>
68 #include <compat/linux/linux_mib.h>
69 #include <compat/linux/linux_util.h>
70 #include <fs/pseudofs/pseudofs.h>
71 
72 #include <linux/debugfs.h>
73 #include <linux/seq_file.h>
74 #include <linux/compat.h>
75 
76 MALLOC_DEFINE(M_DFSINT, "debugfsint", "Linux debugfs internal");
77 
78 static struct pfs_node *debugfs_root;
79 
80 #define DM_SYMLINK 0x1
81 #define DM_DIR 0x2
82 #define DM_FILE 0x3
83 
84 struct dentry_meta {
85 	struct dentry dm_dnode;
86 	const struct file_operations *dm_fops;
87 	void *dm_data;
88 	umode_t dm_mode;
89 	int dm_type;
90 };
91 
92 static int
93 debugfs_attr(PFS_ATTR_ARGS)
94 {
95 	struct dentry_meta *dm;
96 
97 	dm = pn->pn_data;
98 
99 	vap->va_mode = dm->dm_mode;
100 	return (0);
101 }
102 
103 static int
104 debugfs_destroy(PFS_DESTROY_ARGS)
105 {
106 	struct dentry_meta *dm;
107 
108 	dm = pn->pn_data;
109 	if (dm->dm_type == DM_SYMLINK)
110 		free(dm->dm_data, M_DFSINT);
111 
112 	free(dm, M_DFSINT);
113 	return (0);
114 }
115 
116 static int
117 debugfs_fill(PFS_FILL_ARGS)
118 {
119 	struct dentry_meta *d;
120 	struct linux_file lf;
121 	struct seq_file *sf;
122 	struct vnode vn;
123 	void *buf;
124 	int rc;
125 	size_t len;
126 	off_t off;
127 
128 	d = pn->pn_data;
129 
130 	if ((rc = linux_set_current_flags(curthread, M_NOWAIT)))
131 		return (rc);
132 	vn.v_data = d->dm_data;
133 	if (uio->uio_rw == UIO_READ) {
134 		buf = uio->uio_iov[0].iov_base;
135 		len = min(uio->uio_iov[0].iov_len, uio->uio_resid);
136 	} else {
137 		sbuf_finish(sb);
138 		buf = sbuf_data(sb);
139 		len = sbuf_len(sb);
140 	}
141 	off = 0;
142 	lf.private_data = NULL;
143 	rc = d->dm_fops->open(&vn, &lf);
144 	if (rc < 0) {
145 #ifdef INVARIANTS
146 		printf("%s:%d open failed with %d\n", __FUNCTION__, __LINE__, rc);
147 #endif
148 		return (-rc);
149 	}
150 	sf = lf.private_data;
151 	sf->buf = sb;
152 	if (uio->uio_rw == UIO_READ) {
153 		if (d->dm_fops->read)
154 			rc = d->dm_fops->read(&lf, NULL, len, &off);
155 		else
156 			rc = ENODEV;
157 	} else {
158 		if (d->dm_fops->write)
159 			rc = d->dm_fops->write(&lf, buf, len, &off);
160 		else
161 			rc = ENODEV;
162 	}
163 	if (d->dm_fops->release)
164 		d->dm_fops->release(&vn, &lf);
165 	else
166 		single_release(&vn, &lf);
167 
168 	if (rc < 0) {
169 #ifdef INVARIANTS
170 		printf("%s:%d read/write failed with %d\n", __FUNCTION__, __LINE__, rc);
171 #endif
172 		return (-rc);
173 	}
174 	return (0);
175 }
176 
177 static int
178 debugfs_fill_data(PFS_FILL_ARGS)
179 {
180 	struct dentry_meta *dm;
181 
182 	dm = pn->pn_data;
183 	sbuf_printf(sb, "%s", (char *)dm->dm_data);
184 	return (0);
185 }
186 
187 struct dentry *
188 debugfs_create_file(const char *name, umode_t mode,
189 		    struct dentry *parent, void *data,
190 		    const struct file_operations *fops)
191 {
192 	struct dentry_meta *dm;
193 	struct dentry *dnode;
194 	struct pfs_node *pnode;
195 	int flags;
196 
197 	dm = malloc(sizeof(*dm), M_DFSINT, M_NOWAIT | M_ZERO);
198 	if (dm == NULL)
199 		return (NULL);
200 	dnode = &dm->dm_dnode;
201 	dm->dm_fops = fops;
202 	dm->dm_data = data;
203 	dm->dm_mode = mode;
204 	dm->dm_type = DM_FILE;
205 	if (parent != NULL)
206 		pnode = parent->d_pfs_node;
207 	else
208 		pnode = debugfs_root;
209 
210 	flags = fops->write ? PFS_RDWR : PFS_RD;
211 	dnode->d_pfs_node = pfs_create_file(pnode, name, debugfs_fill,
212 	    debugfs_attr, NULL, debugfs_destroy, flags | PFS_NOWAIT);
213 	if (dnode->d_pfs_node == NULL) {
214 		free(dm, M_DFSINT);
215 		return (NULL);
216 	}
217 	dnode->d_pfs_node->pn_data = dm;
218 
219 	return (dnode);
220 }
221 
222 struct dentry *
223 debugfs_create_dir(const char *name, struct dentry *parent)
224 {
225 	struct dentry_meta *dm;
226 	struct dentry *dnode;
227 	struct pfs_node *pnode;
228 
229 	dm = malloc(sizeof(*dm), M_DFSINT, M_NOWAIT | M_ZERO);
230 	if (dm == NULL)
231 		return (NULL);
232 	dnode = &dm->dm_dnode;
233 	dm->dm_mode = 0700;
234 	dm->dm_type = DM_DIR;
235 	if (parent != NULL)
236 		pnode = parent->d_pfs_node;
237 	else
238 		pnode = debugfs_root;
239 
240 	dnode->d_pfs_node = pfs_create_dir(pnode, name, debugfs_attr, NULL, debugfs_destroy, PFS_RD | PFS_NOWAIT);
241 	if (dnode->d_pfs_node == NULL) {
242 		free(dm, M_DFSINT);
243 		return (NULL);
244 	}
245 	dnode->d_pfs_node->pn_data = dm;
246 	return (dnode);
247 }
248 
249 struct dentry *
250 debugfs_create_symlink(const char *name, struct dentry *parent,
251 	const char *dest)
252 {
253 	struct dentry_meta *dm;
254 	struct dentry *dnode;
255 	struct pfs_node *pnode;
256 	void *data;
257 
258 	data = strdup_flags(dest, M_DFSINT, M_NOWAIT);
259 	if (data == NULL)
260 		return (NULL);
261 	dm = malloc(sizeof(*dm), M_DFSINT, M_NOWAIT | M_ZERO);
262 	if (dm == NULL)
263 		goto fail1;
264 	dnode = &dm->dm_dnode;
265 	dm->dm_mode = 0700;
266 	dm->dm_type = DM_SYMLINK;
267 	dm->dm_data = data;
268 	if (parent != NULL)
269 		pnode = parent->d_pfs_node;
270 	else
271 		pnode = debugfs_root;
272 
273 	dnode->d_pfs_node = pfs_create_link(pnode, name, &debugfs_fill_data, NULL, NULL, NULL, PFS_NOWAIT);
274 	if (dnode->d_pfs_node == NULL)
275 		goto fail;
276 	dnode->d_pfs_node->pn_data = dm;
277 	return (dnode);
278  fail:
279 	free(dm, M_DFSINT);
280  fail1:
281 	free(data, M_DFSINT);
282 	return (NULL);
283 }
284 
285 void
286 debugfs_remove(struct dentry *dnode)
287 {
288 	if (dnode == NULL)
289 		return;
290 
291 	pfs_destroy(dnode->d_pfs_node);
292 }
293 
294 void
295 debugfs_remove_recursive(struct dentry *dnode)
296 {
297 	if (dnode == NULL)
298 		return;
299 
300 	pfs_destroy(dnode->d_pfs_node);
301 }
302 
303 static int
304 debugfs_init(PFS_INIT_ARGS)
305 {
306 
307 	debugfs_root = pi->pi_root;
308 
309 	(void)debugfs_create_symlink("kcov", NULL, "/dev/kcov");
310 
311 	return (0);
312 }
313 
314 static int
315 debugfs_uninit(PFS_INIT_ARGS)
316 {
317 	return (0);
318 }
319 
320 #ifdef PR_ALLOW_MOUNT_LINSYSFS
321 PSEUDOFS(debugfs, 1, PR_ALLOW_MOUNT_LINSYSFS);
322 #else
323 PSEUDOFS(debugfs, 1, VFCF_JAIL);
324 #endif
325 MODULE_DEPEND(lindebugfs, linuxkpi, 1, 1, 1);
326