1// SPDX-License-Identifier: GPL-2.0
 2#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 3#include <linux/init.h>
 4#include <linux/module.h>
 
 
 
 5#include "bpf_preload.h"
 6#include "iterators/iterators.lskel.h"
 7
 8static struct bpf_link *maps_link, *progs_link;
 9static struct iterators_bpf *skel;
10
11static void free_links_and_skel(void)
12{
13	if (!IS_ERR_OR_NULL(maps_link))
14		bpf_link_put(maps_link);
15	if (!IS_ERR_OR_NULL(progs_link))
16		bpf_link_put(progs_link);
17	iterators_bpf__destroy(skel);
18}
19
20static int preload(struct bpf_preload_info *obj)
21{
22	strlcpy(obj[0].link_name, "maps.debug", sizeof(obj[0].link_name));
23	obj[0].link = maps_link;
24	strlcpy(obj[1].link_name, "progs.debug", sizeof(obj[1].link_name));
25	obj[1].link = progs_link;
26	return 0;
27}
28
29static struct bpf_preload_ops ops = {
30	.preload = preload,
 
31	.owner = THIS_MODULE,
32};
33
34static int load_skel(void)
35{
36	int err;
 
 
 
37
38	skel = iterators_bpf__open();
39	if (!skel)
40		return -ENOMEM;
41	err = iterators_bpf__load(skel);
42	if (err)
43		goto out;
44	err = iterators_bpf__attach(skel);
45	if (err)
46		goto out;
47	maps_link = bpf_link_get_from_fd(skel->links.dump_bpf_map_fd);
48	if (IS_ERR(maps_link)) {
49		err = PTR_ERR(maps_link);
50		goto out;
 
 
 
 
 
 
 
51	}
52	progs_link = bpf_link_get_from_fd(skel->links.dump_bpf_prog_fd);
53	if (IS_ERR(progs_link)) {
54		err = PTR_ERR(progs_link);
55		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
56	}
57	/* Avoid taking over stdin/stdout/stderr of init process. Zeroing out
58	 * makes skel_closenz() a no-op later in iterators_bpf__destroy().
59	 */
60	close_fd(skel->links.dump_bpf_map_fd);
61	skel->links.dump_bpf_map_fd = 0;
62	close_fd(skel->links.dump_bpf_prog_fd);
63	skel->links.dump_bpf_prog_fd = 0;
64	return 0;
65out:
66	free_links_and_skel();
67	return err;
68}
69
70static int __init load(void)
71{
72	int err;
73
74	err = load_skel();
 
75	if (err)
76		return err;
77	bpf_preload_ops = &ops;
78	return err;
79}
80
81static void __exit fini(void)
82{
 
 
83	bpf_preload_ops = NULL;
84	free_links_and_skel();
 
 
 
 
 
 
 
 
 
85}
86late_initcall(load);
87module_exit(fini);
88MODULE_LICENSE("GPL");

  1// SPDX-License-Identifier: GPL-2.0
  2#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  3#include <linux/init.h>
  4#include <linux/module.h>
  5#include <linux/pid.h>
  6#include <linux/fs.h>
  7#include <linux/sched/signal.h>
  8#include "bpf_preload.h"
 
  9
 10extern char bpf_preload_umd_start;
 11extern char bpf_preload_umd_end;
 12
 13static int preload(struct bpf_preload_info *obj);
 14static int finish(void);
 
 
 
 
 
 
 15
 16static struct bpf_preload_ops umd_ops = {
 17	.info.driver_name = "bpf_preload",
 
 
 
 
 
 
 
 
 18	.preload = preload,
 19	.finish = finish,
 20	.owner = THIS_MODULE,
 21};
 22
 23static int preload(struct bpf_preload_info *obj)
 24{
 25	int magic = BPF_PRELOAD_START;
 26	loff_t pos = 0;
 27	int i, err;
 28	ssize_t n;
 29
 30	err = fork_usermode_driver(&umd_ops.info);
 
 
 
 31	if (err)
 32		return err;
 33
 34	/* send the start magic to let UMD proceed with loading BPF progs */
 35	n = kernel_write(umd_ops.info.pipe_to_umh,
 36			 &magic, sizeof(magic), &pos);
 37	if (n != sizeof(magic))
 38		return -EPIPE;
 39
 40	/* receive bpf_link IDs and names from UMD */
 41	pos = 0;
 42	for (i = 0; i < BPF_PRELOAD_LINKS; i++) {
 43		n = kernel_read(umd_ops.info.pipe_from_umh,
 44				&obj[i], sizeof(*obj), &pos);
 45		if (n != sizeof(*obj))
 46			return -EPIPE;
 47	}
 48	return 0;
 49}
 50
 51static int finish(void)
 52{
 53	int magic = BPF_PRELOAD_END;
 54	struct pid *tgid;
 55	loff_t pos = 0;
 56	ssize_t n;
 57
 58	/* send the last magic to UMD. It will do a normal exit. */
 59	n = kernel_write(umd_ops.info.pipe_to_umh,
 60			 &magic, sizeof(magic), &pos);
 61	if (n != sizeof(magic))
 62		return -EPIPE;
 63
 64	tgid = umd_ops.info.tgid;
 65	if (tgid) {
 66		wait_event(tgid->wait_pidfd, thread_group_exited(tgid));
 67		umd_cleanup_helper(&umd_ops.info);
 68	}
 
 
 
 
 
 
 
 69	return 0;
 
 
 
 70}
 71
 72static int __init load_umd(void)
 73{
 74	int err;
 75
 76	err = umd_load_blob(&umd_ops.info, &bpf_preload_umd_start,
 77			    &bpf_preload_umd_end - &bpf_preload_umd_start);
 78	if (err)
 79		return err;
 80	bpf_preload_ops = &umd_ops;
 81	return err;
 82}
 83
 84static void __exit fini_umd(void)
 85{
 86	struct pid *tgid;
 87
 88	bpf_preload_ops = NULL;
 89
 90	/* kill UMD in case it's still there due to earlier error */
 91	tgid = umd_ops.info.tgid;
 92	if (tgid) {
 93		kill_pid(tgid, SIGKILL, 1);
 94
 95		wait_event(tgid->wait_pidfd, thread_group_exited(tgid));
 96		umd_cleanup_helper(&umd_ops.info);
 97	}
 98	umd_unload_blob(&umd_ops.info);
 99}
100late_initcall(load_umd);
101module_exit(fini_umd);
102MODULE_LICENSE("GPL");