Skip to content

Commit 1f8e5f7

Browse files
niebowen666niebowen666
authored
upload ext4File.bpf.c
1 parent 836d3f0 commit 1f8e5f7

1 file changed

Lines changed: 258 additions & 0 deletions

File tree

‎libbpf-tools/ext4File.bpf.c‎

Lines changed: 258 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,258 @@
1+
// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
2+
// Copyright (c) 2025 Samsung Electronics Co., Ltd.
3+
#include <vmlinux.h>
4+
#include <bpf/bpf_helpers.h>
5+
#include <bpf/bpf_tracing.h>
6+
#include <bpf/bpf_core_read.h>
7+
8+
#include "ext4File.h"
9+
10+
volatile __u64 device_num = 0;
11+
volatile __u64 blocks_per_group = 0;
12+
volatile __u64 system_up = 0;
13+
14+
#define N 16
15+
#define GROUP 64
16+
17+
struct {
18+
__uint(type, BPF_MAP_TYPE_HASH);
19+
__uint(max_entries, 1000000);
20+
__type(key, u32);
21+
__type(value, struct file_info_key);
22+
} ino_name_map SEC(".maps");
23+
struct {
24+
__uint(type, BPF_MAP_TYPE_HASH);
25+
__uint(max_entries, 1000000);
26+
__type(key, struct file_info_key);
27+
__type(value, struct file_info_val);
28+
} file_info_map SEC(".maps");
29+
struct {
30+
__uint(type, BPF_MAP_TYPE_HASH);
31+
__uint(max_entries, 10000000);
32+
__type(key, struct file_bg_key);
33+
__type(value, u64);
34+
} file_bg_map SEC(".maps");
35+
36+
static __always_inline void *
37+
bpf_map_lookup_and_delete(void *map, const void *key)
38+
{
39+
void *val;
40+
41+
val = bpf_map_lookup_elem(map, key);
42+
if (val){
43+
bpf_map_delete_elem(map, key);
44+
}
45+
46+
return 0;
47+
}
48+
49+
SEC("fexit/ext4_add_entry")
50+
int BPF_PROG(my_ext4_add_nondir, handle_t* handle,
51+
struct dentry* dentry, struct inode* inode)
52+
{
53+
struct inode* pa_inode = dentry->d_parent->d_inode;
54+
//bpf_probe_read_kernel(&inode, sizeof(inode), inodep);
55+
dev_t dev = pa_inode->i_sb->s_dev;
56+
u64 ino_id = inode->i_ino;
57+
struct file_info_key fik = {};
58+
struct file_info_val fiv = {}, *fivp;
59+
60+
//bpf_printk("device_num:%d dev:%d\n", device_num, dev);
61+
if (device_num && device_num != dev)
62+
return 0;
63+
64+
fik.fk_ino = ino_id;
65+
fik.fk_pa_ino = pa_inode->i_ino;
66+
bpf_probe_read_kernel(&fik.fk_name,
67+
sizeof(fik.fk_name), dentry->d_name.name);
68+
69+
fiv.fv_access_cnt = 1;
70+
fiv.fv_ts[TS_TYPE_CREATE] =
71+
system_up + bpf_ktime_get_ns() / 1000000000ULL;
72+
73+
if (bpf_map_update_elem(&file_info_map, &fik, &fiv, BPF_ANY))
74+
bpf_printk("failed to update file_info_map\n");
75+
if (bpf_map_update_elem(&ino_name_map, &ino_id, &fik, BPF_ANY))
76+
bpf_printk("failed to update ino_name_map\n");
77+
return 0;
78+
}
79+
80+
SEC("fentry/ext4_file_write_iter")
81+
int BPF_PROG(my_ext4_file_write_iter,
82+
struct kiocb *iocb, struct iov_iter *from)
83+
{
84+
struct file* file = iocb->ki_filp;
85+
struct inode* inode = file->f_inode;
86+
dev_t dev = inode->i_sb->s_dev;
87+
u64 cur_time = bpf_ktime_get_ns() / 1000000000ULL;
88+
struct file_info_key* fikp = NULL;
89+
struct file_info_val* fivp = NULL;
90+
u64 ino_id = inode->i_ino;
91+
long long offset = iocb-> ki_pos;
92+
if (device_num && device_num != dev)
93+
return 0;
94+
95+
fikp = bpf_map_lookup_elem(&ino_name_map, &ino_id);
96+
if (!fikp) {
97+
bpf_printk("fail to find fikp: %d", ino_id);
98+
return 0;
99+
}
100+
101+
fivp = bpf_map_lookup_elem(&file_info_map, fikp);
102+
if (!fivp) {
103+
bpf_printk("failed to lookup file_info_map\n");
104+
return 0;
105+
}
106+
107+
fivp->fv_size = inode->i_size;
108+
fivp->fv_hint = inode->i_write_hint;
109+
fivp->fv_ts[TS_TYPE_MODIFY] = cur_time + system_up;
110+
__sync_fetch_and_add(&fivp->fv_access_cnt, 1);
111+
if(offset < fivp->fv_size) {
112+
__sync_fetch_and_add(&fivp->fv_update_cnt, 1);
113+
} else {
114+
if(iocb->ki_flags & IOCB_DIRECT)
115+
__sync_fetch_and_add(&fivp->fv_rw_cnt[RW_TYPE_DIRECT_WRITE], 1);
116+
else
117+
__sync_fetch_and_add(&fivp->fv_rw_cnt[RW_TYPE_BUFFER_WRITE], 1);
118+
}
119+
fivp->fv_ts[TS_TYPE_ACCESS] = cur_time + system_up;
120+
121+
return 0;
122+
}
123+
124+
SEC("fentry/ext4_file_read_iter")
125+
int BPF_PROG(my_ext4_file_read_iter,
126+
struct kiocb *iocb, struct iov_iter *to)
127+
{
128+
//bpf_printk("ext4_file_read_iter\n");
129+
struct file* file = iocb->ki_filp;
130+
struct inode* inode = file->f_inode;
131+
dev_t dev = inode->i_sb->s_dev;
132+
u64 cur_time = bpf_ktime_get_ns() / 1000000000ULL;
133+
struct file_info_key* fikp = NULL;
134+
struct file_info_val* fivp = NULL;
135+
u64 ino_id = inode->i_ino;
136+
//bpf_printk("device_num:%d dev:%d\n", device_num, dev);
137+
if (device_num && device_num != dev)
138+
return 0;
139+
140+
fikp = bpf_map_lookup_elem(&ino_name_map, &ino_id);
141+
if (!fikp) {
142+
bpf_printk("fail to find fikp: %d", ino_id);
143+
return 0;
144+
}
145+
146+
fivp = bpf_map_lookup_elem(&file_info_map, fikp);
147+
if (!fivp) {
148+
bpf_printk("failed to lookup file_info_map\n");
149+
return 0;
150+
}
151+
152+
fivp->fv_size = inode->i_size;
153+
__sync_fetch_and_add(&fivp->fv_access_cnt, 1);
154+
if (iocb->ki_flags & IOCB_DIRECT)
155+
__sync_fetch_and_add(&fivp->fv_rw_cnt[RW_TYPE_DIRECT_READ], 1);
156+
else
157+
__sync_fetch_and_add(&fivp->fv_rw_cnt[RW_TYPE_BUFFER_READ], 1);
158+
fivp->fv_ts[TS_TYPE_ACCESS] = cur_time + system_up;
159+
160+
return 0;
161+
}
162+
163+
SEC("fentry/ext4_rmdir")
164+
int BPF_PROG(my_ext4_rmdir,
165+
struct inode* dir, struct dentry* dentry)
166+
{
167+
struct inode* inode = dentry->d_inode;
168+
struct file_info_key* fikp = NULL;
169+
struct file_info_val* fivp = NULL;
170+
u64 cur_time = bpf_ktime_get_ns() / 1000000000ULL;
171+
u64 ino_id = inode->i_ino;
172+
173+
fikp = bpf_map_lookup_elem(&ino_name_map, &ino_id);
174+
if (!fikp) {
175+
bpf_printk("fail to find fikp: %d", ino_id);
176+
return 0;
177+
}
178+
179+
fivp = bpf_map_lookup_elem(&file_info_map, fikp);
180+
if (!fivp) {
181+
bpf_printk("fail to find fivp: %d", fivp);
182+
return 0;
183+
}
184+
fivp->fv_ts[TS_TYPE_ACCESS] = cur_time + system_up;
185+
fivp->fv_ts[TS_TYPE_DELETE] = cur_time + system_up;
186+
bpf_map_lookup_and_delete(&ino_name_map, &ino_id);
187+
return 0;
188+
}
189+
190+
SEC("tp_btf/ext4_unlink_enter")
191+
int BPF_PROG(my_ext4_unlink,
192+
struct inode * pa_inode, struct dentry *dentry)
193+
{
194+
struct inode* inode = dentry->d_inode;
195+
struct file_info_key* fikp = NULL;
196+
struct file_info_val* fivp = NULL;
197+
u64 cur_time = bpf_ktime_get_ns() / 1000000000ULL;
198+
u64 ino_id = inode->i_ino;
199+
200+
fikp = bpf_map_lookup_elem(&ino_name_map, &ino_id);
201+
if (!fikp) {
202+
bpf_printk("fail to find fikp: %d", ino_id);
203+
return 0;
204+
}
205+
206+
fivp = bpf_map_lookup_elem(&file_info_map, fikp);
207+
if (!fivp) {
208+
bpf_printk("fail to find fivp: %d", fivp);
209+
return 0;
210+
}
211+
212+
fivp->fv_ts[TS_TYPE_ACCESS] = cur_time + system_up;
213+
fivp->fv_ts[TS_TYPE_DELETE] = cur_time + system_up;
214+
bpf_map_lookup_and_delete(&ino_name_map, &ino_id);
215+
return 0;
216+
}
217+
218+
static void insert_file_bg_map(u64 bg_id, struct file_bg_key* fbgkp)
219+
{
220+
u64 bit_pos = bg_id % GROUP;
221+
fbgkp->bgk_index = bg_id / GROUP;
222+
u64 n = flag(bit_pos);
223+
u64* t = bpf_map_lookup_elem(&file_bg_map, fbgkp);
224+
if (t)
225+
*t = *t | n;
226+
else {
227+
if(bpf_map_update_elem(&file_bg_map, fbgkp, &n, BPF_ANY))
228+
bpf_printk("failed to update file_bg_map\n");
229+
}
230+
}
231+
232+
SEC("tp_btf/ext4_ext_map_blocks_exit")
233+
int BPF_PROG(my_ext4_ext_map_blocks_exit, struct inode *inode, unsigned int a,
234+
struct ext4_map_blocks *map, int flags) {
235+
dev_t dev = inode->i_sb->s_dev;
236+
u32 ino_id = inode->i_ino;
237+
u64 phy_blk_beg = map->m_pblk;
238+
u64 phy_blk_end = map->m_pblk + map->m_len;
239+
u64 bg_id_beg = phy_blk_beg / blocks_per_group;
240+
u64 bg_id_end = phy_blk_end / blocks_per_group;
241+
struct file_bg_key fbgk = {};
242+
if (device_num && device_num != dev)
243+
return 0;
244+
struct file_info_key* fikp = bpf_map_lookup_elem(&ino_name_map, &ino_id);
245+
if (!fikp) {
246+
bpf_printk("failed to lookup ino_name_map: %d\n", ino_id);
247+
return 0;
248+
}
249+
fbgk.bgk_fik.fk_ino = fikp->fk_ino;
250+
fbgk.bgk_fik.fk_pa_ino = fikp->fk_pa_ino;
251+
bpf_probe_read_kernel(&fbgk.bgk_fik.fk_name,
252+
sizeof(fbgk.bgk_fik.fk_name), fikp->fk_name);
253+
insert_file_bg_map(bg_id_beg, &fbgk);
254+
return 0;
255+
}
256+
257+
char LICENSE[] SEC("license") = "Dual BSD/GPL";
258+

0 commit comments

Comments
 (0)