Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

cpu_watcher：用户态互斥锁测试 #887

Merged
merged 2 commits into from
Sep 13, 2024
Merged

cpu_watcher：用户态互斥锁测试 #887

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
d36874c
用户态互斥锁测试
vvzxy Aug 16, 2024
4e1d172
revision
vvzxy Sep 7, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
206 changes: 85 additions & 121 deletions eBPF_Supermarket/CPU_Subsystem/cpu_watcher/bpf/mutrace.bpf.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,88 +33,89 @@ struct {
} rb SEC(".maps");

static inline struct mu_ctrl *get_mu_ctrl(void) {
struct mu_ctrl *mu_ctrl;
mu_ctrl = bpf_map_lookup_elem(&mu_ctrl_map, &ctrl_key);
if (!mu_ctrl || !mu_ctrl->mu_func) {
return NULL;
}
return mu_ctrl;
struct mu_ctrl *mu_ctrl = bpf_map_lookup_elem(&mu_ctrl_map, &ctrl_key);
return (mu_ctrl && mu_ctrl->mu_func) ? mu_ctrl : NULL;
}

/*----------------------------------------------*/
/* 内核态互斥锁 */
/*----------------------------------------------*/
static inline void update_mutex_info(struct mutex_info *info, u64 ts, pid_t pid) {
info->acquire_time = ts;
info->last_owner = pid;
bpf_get_current_comm(&info->last_name, sizeof(info->last_name));
}

static inline void init_mutex_info(struct mutex_info *info, u64 lock_addr, u64 ts, pid_t pid) {
info->locked_total = 0;
info->locked_max = 0;
info->contended_total = 0;
info->count = 0;
info->last_owner = pid;
info->acquire_time = ts;
info->ptr = lock_addr;
__builtin_memset(info->last_name, 0, sizeof(info->last_name));
bpf_get_current_comm(&info->last_name, sizeof(info->last_name));
}

SEC("kprobe/mutex_lock")
int BPF_KPROBE(trace_mutex_lock, struct mutex *lock) {
u64 lock_addr = (u64)lock; // 获取锁地址
struct mu_ctrl *mu_ctrl = get_mu_ctrl();
u64 lock_addr = (u64)lock;
u64 ts = bpf_ktime_get_ns();
struct mutex_info *info = bpf_map_lookup_elem(&kmutex_info_map, &lock_addr);

if (info) {
info->acquire_time = ts; // 保存锁获取时间
info->acquire_time = ts;
} else {
struct mutex_info new_info = {
.locked_total = 0,
.locked_max = 0,
.contended_total = 0,
.count = 0,
.last_owner = 0,
.acquire_time = ts,
.ptr = lock_addr
};
__builtin_memset(new_info.last_name, 0, sizeof(new_info.last_name));
struct mutex_info new_info;
init_mutex_info(&new_info, lock_addr, ts, 0);
bpf_map_update_elem(&kmutex_info_map, &lock_addr, &new_info, BPF_ANY);
}

return 0;
}

SEC("kprobe/mutex_trylock")
int BPF_KPROBE(trace_mutex_trylock, struct mutex *lock) {
struct mu_ctrl *mu_ctrl = get_mu_ctrl();
int ret = PT_REGS_RC(ctx);
if (ret != 0) { // 成功获取锁
u64 lock_addr = (u64)lock; // 获取锁地址
if (ret != 0) {
u64 lock_addr = (u64)lock;
u64 ts = bpf_ktime_get_ns();
struct mutex_info *info = bpf_map_lookup_elem(&kmutex_info_map, &lock_addr);

if (info) {
info->acquire_time = ts;
} else {
struct mutex_info new_info = {
.locked_total = 0,
.locked_max = 0,
.contended_total = 0,
.count = 0,
.last_owner = 0,
.acquire_time = ts,
.ptr = lock_addr
};
__builtin_memset(new_info.last_name, 0, sizeof(new_info.last_name));
struct mutex_info new_info;
init_mutex_info(&new_info, lock_addr, ts, 0);
bpf_map_update_elem(&kmutex_info_map, &lock_addr, &new_info, BPF_ANY);
}
}

return 0;
}

SEC("kprobe/__mutex_lock_slowpath")
int BPF_KPROBE(trace_mutex_lock_slowpath, struct mutex *lock) {
struct mu_ctrl *mu_ctrl = get_mu_ctrl();
struct mutex_contention_event *e;
struct task_struct *owner_task;
struct task_struct *contender_task;
pid_t pid = bpf_get_current_pid_tgid();
long owner;
if (!mu_ctrl) return 0;

u64 lock_addr = (u64)lock;
u64 ts = bpf_ktime_get_ns();
e = bpf_ringbuf_reserve(&rb, sizeof(*e), 0);
if (!e) {
return 0;
}
struct mutex_contention_event *e = bpf_ringbuf_reserve(&rb, sizeof(*e), 0);
if (!e) return 0;

pid_t pid = bpf_get_current_pid_tgid();
struct task_struct *owner_task, *contender_task;
long owner;

e->contender_pid = pid;
e->ptr = lock_addr;
bpf_get_current_comm(&e->contender_name, sizeof(e->contender_name));
bpf_probe_read_kernel(&owner, sizeof(owner), &lock->owner);
owner_task = (struct task_struct *)(owner & ~0x1L);
contender_task = (struct task_struct *)bpf_get_current_task();
bpf_probe_read_kernel(&e->contender_prio, sizeof(e->contender_prio), &contender_task->prio);

if (owner_task) {
bpf_probe_read_kernel(&e->owner_pid, sizeof(e->owner_pid), &owner_task->pid);
bpf_probe_read_kernel_str(&e->owner_name, sizeof(e->owner_name), owner_task->comm);
Expand All @@ -123,89 +124,75 @@ int BPF_KPROBE(trace_mutex_lock_slowpath, struct mutex *lock) {
e->owner_pid = 0;
__builtin_memset(e->owner_name, 0, sizeof(e->owner_name));
}

struct mutex_info *info = bpf_map_lookup_elem(&kmutex_info_map, &lock_addr);
if (info) {
u64 contention_start = ts;
info->contended_total += (contention_start - info->acquire_time); // 更新争用时间
info->count++; // 更新争用次数
info->contended_total += (contention_start - info->acquire_time);
info->count++;
} else {
struct mutex_info new_info = {
.locked_total = 0,
.locked_max = 0,
.contended_total = 0,
.count = 1, // 初始化争用次数
.last_owner = 0,
.acquire_time = ts, // 初始化获取时间
.ptr = lock_addr
};
__builtin_memset(new_info.last_name, 0, sizeof(new_info.last_name));
struct mutex_info new_info;
init_mutex_info(&new_info, lock_addr, ts, 0);
new_info.count = 1;
bpf_map_update_elem(&kmutex_info_map, &lock_addr, &new_info, BPF_ANY);
}

bpf_ringbuf_submit(e, 0);
return 0;
}

SEC("kprobe/mutex_unlock")
int BPF_KPROBE(trace_mutex_unlock, struct mutex *lock) {
struct mu_ctrl *mu_ctrl = get_mu_ctrl();
u64 lock_addr = (u64)lock;
u64 ts = bpf_ktime_get_ns();
pid_t pid = bpf_get_current_pid_tgid();
struct mutex_info *info = bpf_map_lookup_elem(&kmutex_info_map, &lock_addr);

if (info) {
u64 held_time = ts - info->acquire_time; // 计算锁被持有的时间
info->locked_total += held_time; // 更新锁被持有的总时间
u64 held_time = ts - info->acquire_time;
info->locked_total += held_time;
if (held_time > info->locked_max) {
info->locked_max = held_time; // 更新锁被持有的最长时间
info->locked_max = held_time;
}
info->last_owner = pid; // 更新最后一次持有该锁的线程ID
bpf_get_current_comm(&info->last_name, sizeof(info->last_name)); // 更新最后一次持有该锁的线程名称
info->last_owner = pid;
bpf_get_current_comm(&info->last_name, sizeof(info->last_name));
}

return 0;
}



/*----------------------------------------------*/
/* 用户态互斥锁 */
/*----------------------------------------------*/



SEC("uprobe/pthread_mutex_lock")
int BPF_KPROBE(pthread_mutex_lock, void *__mutex) {
u64 pid_tgid = bpf_get_current_pid_tgid();
pid_t pid = pid_tgid >> 32;
u64 now = bpf_ktime_get_ns();

static inline void handle_user_mutex_lock(void *__mutex, u64 now, pid_t pid) {
struct mutex_info *info = bpf_map_lookup_elem(&umutex_info_map, &__mutex);
if (info) {
if (info->acquire_time > 0) {
// 如果 acquire_time 已经被设置，说明锁被争用
info->contended_total += (now - info->acquire_time);
info->count += 1;
info->count++;
}
info->acquire_time = now;
info->last_owner = pid;
bpf_get_current_comm(&info->last_name, sizeof(info->last_name));
update_mutex_info(info, now, pid);
} else {
// 初始化 mutex_info
struct mutex_info new_info = {
.locked_total = 0,
.locked_max = 0,
.contended_total = 0,
.count = 0,
.last_owner = pid,
.acquire_time = now,
.ptr = (u64)__mutex,
};
bpf_get_current_comm(&new_info.last_name, sizeof(new_info.last_name));
struct mutex_info new_info;
init_mutex_info(&new_info, (u64)__mutex, now, pid);
bpf_map_update_elem(&umutex_info_map, &__mutex, &new_info, BPF_ANY);
}
}

SEC("uprobe/pthread_mutex_lock")
int BPF_KPROBE(pthread_mutex_lock, void *__mutex) {
struct mu_ctrl *mu_ctrl = get_mu_ctrl();
u64 now = bpf_ktime_get_ns();
pid_t pid = bpf_get_current_pid_tgid() >> 32;
handle_user_mutex_lock(__mutex, now, pid);
return 0;
}

SEC("uprobe/__pthread_mutex_trylock")
int BPF_KPROBE(__pthread_mutex_trylock, void *__mutex) {
struct mu_ctrl *mu_ctrl = get_mu_ctrl();
u64 pid_tgid = bpf_get_current_pid_tgid();
u64 now = bpf_ktime_get_ns();
struct trylock_info info = {
Expand All @@ -218,55 +205,32 @@ int BPF_KPROBE(__pthread_mutex_trylock, void *__mutex) {

SEC("uretprobe/__pthread_mutex_trylock")
int BPF_KRETPROBE(ret_pthread_mutex_trylock, int ret) {
struct mu_ctrl *mu_ctrl = get_mu_ctrl();
u64 pid_tgid = bpf_get_current_pid_tgid();
struct trylock_info *try_info = bpf_map_lookup_elem(&trylock_map, &pid_tgid);
if (!try_info) {
return 0;
}
void *__mutex = try_info->__mutex;
u64 now = bpf_ktime_get_ns();
if (!try_info) return 0;

if (ret == 0) {
struct mutex_info *info = bpf_map_lookup_elem(&umutex_info_map, &__mutex);
if (info) {
if (info->acquire_time > 0) {
// 如果 acquire_time 已经被设置，说明锁被争用
info->contended_total += (now - info->acquire_time);
info->count += 1;
}
info->acquire_time = now;
info->last_owner = pid_tgid >> 32;
bpf_get_current_comm(&info->last_name, sizeof(info->last_name));
} else {
// 初始化 mutex_info
struct mutex_info new_info = {
.locked_total = 0,
.locked_max = 0,
.contended_total = 0,
.count = 0,
.last_owner = pid_tgid >> 32,
.acquire_time = now,
.ptr = (u64)__mutex,
};
bpf_get_current_comm(&new_info.last_name, sizeof(new_info.last_name));
bpf_map_update_elem(&umutex_info_map, &__mutex, &new_info, BPF_ANY);
}
handle_user_mutex_lock(try_info->__mutex, try_info->start_time, pid_tgid >> 32);
}
bpf_map_delete_elem(&trylock_map, &pid_tgid);
return 0;
}

SEC("uprobe/pthread_mutex_unlock")
int BPF_KPROBE(pthread_mutex_unlock, void *__mutex){
int BPF_KPROBE(pthread_mutex_unlock, void *__mutex) {
struct mu_ctrl *mu_ctrl = get_mu_ctrl();
u64 now = bpf_ktime_get_ns();
pid_t pid = bpf_get_current_pid_tgid() >> 32;
struct mutex_info *info = bpf_map_lookup_elem(&umutex_info_map, &__mutex);
if (info) {
u64 locked_time = now - info->acquire_time;
info->locked_total += locked_time;
if (locked_time > info->locked_max) {
info->locked_max = locked_time;
u64 held_time = now - info->acquire_time;
info->locked_total += held_time;
if (held_time > info->locked_max) {
info->locked_max = held_time;
}
info->acquire_time = 0;
info->last_owner = pid;
bpf_get_current_comm(&info->last_name, sizeof(info->last_name));
}
return 0;
}

Loading
Loading