Good video.

Thanks for the vid

Excellent video. Only missing thing was, If there are multiple threads in process, how kernel will identify which thread to interrupt. Is it the one which raises system call first?

Please please tell me what VS code theme this is? So easy on the eyes

I'm learning a lot from your channel. Not sure if it's the right place to ask but do you have any recommendations on where to start learning assembly for a beginner that does have knowledge in C? There are so many options that I simply do not know where to start.

I heard the intro as: At some point, we want our problems to communicate with other problems.

This videos are gold

I like that you described it as for people who already know something, but don't know how interrupts work, so it doesn't start by explaining how assembly works. Great video, I learned a lot.

@kimylamp Nice work showing the kernel source code to track the signal handler implementation. But you missed something. printf is not signal safe, at all. For a list of detailed signal-safe system calls (write is not one of them), go to man7 signal-safety(7)

Thank you for this! Very informative.

Excellent content as always. Thank you for delivering this. But I would love to have more detail on that special stack, using for storing return function addresses. Anyway, many thanks!

Excellent content! I hope your channel receiving more attention.

this edit goes so hard 🔥

from manpage: sigreturn() exists only to allow the implementation of signal handlers.

What do you use to make these effects?

this video is awesome, but i guess my background is not good enough to fully appreciate it .. ㅜㅜㅜㅜㅜㅜㅜㅜㅜㅜ

ty so much for explanation !!!!

Swear to god I can hear the clock in the background

Signals are a total misconception.

Thank you! The best

Hey don’t use ai. There are plenty of willing artists out there that deserved to be payed. AI relies on the un-consenting use of artist’s work for training.

i still gotta watch this video but it might be cool for you to make something about the device model

dotfiles please

Dude. I'm a tad jaded, and generally expect unfamiliar youtubers to be a bit sheit. It's background noise and an occasional interesting idea for me. You full on stole my attention and kept me from getting anything done! Good stuff, my dude!

Wow, inserting an extra syscall trampoline like that is really clever. it was all very normal up to that point, but I don't think I'd ever have thought of that (or I'd write it off as an insane hack that would probably break).

Hi @kimylamp, can I ask you which software do you use to make the animation of your videos?

What a time to be alive, when videos like this exist

What is the colorscheme in VSCode?

No wonder it took you years to figure this out, wtf. All this time using a pattern I thought was relatively straight forward, and it turns out the nitty gritty of how signals are actually sent is confusing as hell.

man this is complicated

5:24 "now I will mark the ...?... process" what are you saying there?

Great video! How do you make these animations? 01:24

flash back programming interrupts in 80's ! aaaah hardware interrupts and software interrupts... ..

I've been taught not to use printf inside a signal handler

Very useful content. Thank you!

Still too complicated for me

Great content! Can you please share what tools do you use for animations?

Your videos are incredible. Thank you for breaking those topics down into such an understandable form.

# Signals Cheat Sheet ## Signal Handling Mechanism 1. Program registers a signal handler for a specific signal using the `signal` system call. 2. Another process sends the signal to the program using the `kill` system call. 3. Kernel marks the program with a "signal pending" flag. 4. When the program jumps to kernel code (interrupt, exception, or system call), the kernel checks the "signal pending" flag. 5. If the flag is set, the kernel replaces the program's saved program counter with the address of the registered signal handler. 6. The kernel resumes the program, which now jumps to the signal handler instead of the original code. ## Interrupt Handling in ARM64 - CPU jumps to the interrupt handler address stored in the `VBAR_EL1` register. - Kernel saves all user registers to memory in a `pt_regs` structure. - Kernel handles the interrupt and checks for pending signals. - If a signal is pending, the kernel replaces the saved program counter in `pt_regs` with the signal handler address. - Kernel restores registers from `pt_regs` and jumps back to the signal handler. ## Signal Handler Execution - Signal handler code executes using the user stack. - Original register values are saved on the user stack before executing the signal handler. - When the signal handler finishes, it jumps to a trampoline code using the `ret` instruction. - Trampoline code invokes the `rt_sigreturn` system call to restore the original register values. - Kernel restores the original register values from the user stack and resumes the program from where it was interrupted. ## Code Examples ### Registering a Signal Handler ```c #include <signal.h> void signal_handler(int signum) { // Signal handling code } int main() { signal(SIGUSR1, signal_handler); // Rest of the program } ``` ### Sending a Signal ```c #include <signal.h> int main() { pid_t pid = /* Get the target process ID */; kill(pid, SIGUSR1); } ``` ### Trampoline Code (Assembly) ```assembly rt_sigreturn_trampoline: mov x8, #__NR_rt_sigreturn svc 0 ``` ## Important Points - Signals can arrive at any moment during program execution. - The kernel saves the original register values on the user stack before executing the signal handler. - Local variables stored beyond the stack pointer may be overwritten by the kernel when saving registers or executing the signal handler. - Nested signals are handled by saving register values on the user stack to avoid overflowing the kernel stack. This cheat sheet provides an overview of the signal handling mechanism, interrupt handling in ARM64, and the execution flow of signal handlers. It also includes code examples for registering a signal handler, sending a signal, and the trampoline code used to restore the original register values after the signal handler finishes.

Man, thanks, it’s good but not for mobile screens

a very good explanation and hard work , good animation , keep going

This is such a great video! thank you

Fantastic ... finally someone that explained assembly in an easy to understand way!

really good video ngl

Beautiful Description

Дякую!

Hello! I’m teaching a class in embedded systems and I like you explanation a lot, so I want to explain the stack concept in the way you do but in spanish. Is it okay if I use the structure and information you give here to create some slides for my class? :)

The layout is just beautiful and the instructions are crystal clear.

Bad example. You CANNOT call printf() from within a signal handler. printf is not async-safe [it may call malloc() internally while interrupting inside of malloc()]

Learnt more C and Assembly than I did in 4 years of college in 21 minutes, you're a legendary instructor mate thank you for your service ❤