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

I did a double-take when I saw the AArch64 assembly... most KZfaqrs go straight to x86/x64 when talking about assembly, even though it's really not as beginner-friendly as RISC sets, so it's a breath of fresh air seeing someone introducing beginners to ARM. :)

It looks like my process miss a signal every now and then. After watching this video, I think the issue is on my side, but I triple checked all the code. What a life.

So many high quality low level educational videos are being recommended nowadays, your is definitely one of them! I really like the "raw" work with objdump disassembly

I swear this channel will blow up someday. I really like the chosen topics and presentation on this channel.

6:15 what i liked- what i LOVED about this succinct, anthropomorphic explanation is that it really helped frame for me (a software engineer) how to think about the contractual interface i have with the hardware engineers without having to know about the details of CPU architecture. overall just TERRIFIC presentation and formatting.

just saw the words 2 years and i clicked and subscribed. Knowledge takes time and effort. This title clearly says it too

I cant even imagine what it must be like to "map" the kernel code in your brain because your explanation here was spot on. I have always (ie almost 6 years in SDe industry and 6 years of education before that) at a very high level just "assumed" that signals and interrupts are a thing and I know for a fact that I cannot dive into Kernel code to save my life but this video explanation I can definitely say I understood everything. That's definitely a kudos to you sir. I wish to understand more low level systems stuff more in detail as I continue my journey.

I find it amazing that every time an interrupt happens the CPU does this and it’s still able to be so performant.

Your videos, explanations, animations, are all absolutely stellar. So clear, so efficient. PLEASE keep sharing the knowledge, this is truly remarkable.

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 ❤

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!

the video's quality and information are truly stunning

Great video! I like your choice to explain everything with ARM assembly, instead of x86. You earned a new subscriber :)

00:00 💡 Programs need to communicate with each other, often by executing functions when signals are received. 01:24 🛠 Interrupts allow the CPU to break from its natural instruction flow to handle external events like keyboard inputs. 02:30 💾 Kernel preserves user register values when handling interrupts by saving them to memory. 04:03 🔄 Replacing the program counter at the right moment allows the CPU to jump to a signal handler function. 04:41 🌐 Programs can register signal handlers with the kernel to respond to specific signals. 05:57 📜 Examining kernel code reveals how the CPU knows where to jump when an interrupt occurs. 07:18 🕵 Disassembling kernel binaries uncovers the implementation details of interrupt handling. 09:00 🔍 Detailed exploration reveals how the kernel handles interrupts and resumes user processes. 10:49 🛑 Ensuring the kernel stack is empty before handling a signal prevents overflow and nested signals. 12:07 ↩ Saving original register values to the user stack enables restoration after the signal handler executes. 14:16 ⬆ Understanding stack behavior in kernel space is crucial for signal handling and process resumption. 19:00 🎭 A kernel trampoline allows the CPU to jump back to kernel code after the signal handler finishes. 20:45 📺 Bonus: An additional video discusses a compiler bug related to reading local variables beyond the stack pointer.

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

It's like I didn't understand anything but still watched it, thanks for the video

Very nice teaching method, by resolving problems one by one. Great video !!! Respect to the knowledge level. I don't know if many of us will need it daily, but i hope many of us who want to know how it is done inside, will gather to such level that you will keep sharing your wisodm with us.

I will watch this again in like 6 months and go "ooohhh" (actually, I already understood like 75% of the video without knowing a single thing about signals, just gotta get that remaining 25%)

You make it amazingly clear!!! You deserve more subscribers!

Your channel is so good! Outstanding! Keep up the good work.

Keep it up man, worth watching. Thanks 👍

This is some quality education. Puts many universities to shame. Thank you! Could you do one one on re-entrant functions and signal safety? I don't think I completely understand why a thread-safe function isn't also re-entrant. Thank you for the video, appreciate it! Liked and subscribed ❤

Wow great timing, this is literally exactly what I am battling with at the moment.

Very good explanation. Keep up the good work!

I just got my head around 14-bit PIC interrupts (at least on some level), and this absolutely blew my mind.

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

Very useful content. Thank you!

Excellent explanation. I now want to add interrupt functionality to my cpu architecture. Im also thinking about adding flags.

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).

Time well spend and explained in depth

Cool. Good to know that we can use the bonus part to possibly get some escalated data into userspace until interrupt gets executed.

Such a high quality video, thank you very much

This is such a great video! thank you

The internet certainly does not have enough low level programming information available, so things like that are always appreciated. I never worked on ARM but many other risc micro controllers. Also implementing preemptive / cooperative multitasking based on interrupts on x86 is somewhat simpler. This can even be done in the classic real mode. Since x86 stores the interrupt return address on the normal stack, in order to do a context switch you really just need to exchange the stack pointer / stack frame. Each "process" would have it's own stack area. So a process could invoke a software interrupt (cooperative) or a hardware interrupt like a timer (preemptive) could interrupt the execution of a process and the interrupt handler takes over. Besides the automaically stored return address, the handler would save the registers in the user stack frame and then just exchange the stack to the stack of a different process. As a result when the interrupt handler does it's iret, it returns to where this process has left off the last time. My dad actually developed quite complex machine control software back in the 80s and 90s and they used a DOS powered machine that ran over 2000 "tasks". Many task where really small, did just one or two checks and then yield again. They circled through all tasks hundreds of times per second. The actual pascal library mtask is really simple, just around 515 lines of code with many comments (with the comments stripped out it's just around 320 and with a bit different syntax style just 230 lines :)). Quite an impressive library from an ancient time. Of course it does not really apply to any modern system except embedded and microcontroller development where you don't really have a separate kernel. Though the fundamental concepts are still the same.

Wow very impressive, thank you and keep doing a great work please!!

If only had this video a few years ago when had to learn arm64 for the job, specifically port our kernel(OS) to it. Took a hot minute, to say the least, to understand concept of interrupt vector tables and under workings of the assembly

Excellent explanation!

Awesome explanation!!!

Beautiful Description

this is perfect asmr for my brain

This was such a great video, keep it up man you earned a sub from me.

I love the animation style of your videos. How did you come up with this? I’d love to use this to present topics to colleagues

This is great, so much pleasure watching this, thank you for the great work! LOVED your presentation being "everything happens everywhere at once" diagrams! I wish my debuggers could do that, haha. I'm gonna rewatch it again, making sure I've looked at every detail in your illustrations. Have you considered looking into the more general idea? After all, Linux is conceptually UNIX, and UNIX is all about portability, thus signals is just a portable way of implementing interrupts-driven compute. (Then again Windows has it differently with its SEH.) The general idea of interrupts is fascinating in their own right, like Dijkstra famously said: "It was a great invention, but also a Box of Pandora. Because the exact moments of the interrupts were unpredictable and outside our control, the interrupt mechanism turned the computer into a nondeterministic machine with a nonreproducible behavior, and could we control such a beast?" If you have, and in the chance you have time on your hands, I'd LOVE to see your amazingly enlightening approach applied to visualization of more than just signals :) I know, it's a lot to ask, but one can hope, haha. KZfaq likes to eat comments containing URL-like strings, but I'll try to put a link a response to my own comment to a wonderful page on interrupts history you very probably have seen already, from Mark Smotherman.

Thank you

Fantastic video! 😁

Great video, I always like low level OS stuff, always fun. But most programmers would have a different idea in mind when discussing interprocess communication. named and anonymous mutex, semafores, pipes, sockets,shared memory, stdin/stdout/stderr and Maybe even COM on windows.

Such a good video.

amazing visuals

Great video, I think that only thing that is missing is explanation about EL0_EL1 - not every arch has different banks for them.

Great video! I think it could have underlined a bit more that these details are specifically about AArch64. The x86-64 implements some details a bit differently but knowing either one helps a lot in understanding the another.

An excellent video!

What software do you use for this kind of animation?

Bro cooked on this video. Respect.

Thanks!

Amazing video :)

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

without OS, this is way easier to do, absolute control of the Processor counter xD

really good video ngl

Amazing ❤

I'm very curious about this msr and mrs instructions that are skipped by the branch. @ 8:50 I looked it up, and Move System to Register, and Move Register to System, seem like they would be useful as part of the interrupt process. I wonder if there is special kernel code that can conditionally call into this interupt offset to skip the branch instruction?

I think the first branch and the bytes skipped is for instrumentation, either debugging/probes or hot code patch

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

What is the colorscheme in VSCode?

What happens if another interrupt replaces the hardware "saved_user_pc" before the kernel had time to save the state from the first interrupt?

Would it be useful for a CPU to have kernel only registers? That way the kernel wouldn't have to save and restore user-space registers all the time. Although, I guess it wouldn't really save much since the kernel has to do that a bunch for application scheduling anyway.

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

4:48 Hey, this example is really bad. Your signal handler does not follow the correct prototype of void (*handler)(int). Also, the signal handler is required to be reentrant or async signal-safe. Your function is not because it uses global state int signal_arrived instead of some volatile sig_atomic_t or other lock-free atomic global. In this case, you should probably use atomic_flag because it is guaranteed to be lock-free and your example doesn't care about what the value of the signal is. Furthermore, it calls printf() which is also not reentrant. Though, on a posix system you could replace it with a call to write()

Дякую!

Love your videos! Though I think they might age better if you did Rust instead of C.

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

how do you make these videos? they are beautiful!

❤

A KZfaq gold 🎉

Can you share your color scheme? Thank you

Too complex, imma build spaghetti with boost::interprocess instead.

Program A runs on boot. Program B causes a kernel panick immediatly rebooting the pc. problem solved

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

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

1:00 while not particularly relevant to the discussion (it's just an example), one should be careful with infinite loops... int main(){ while(true){}; return 0; } C++ x86-64 clang (trunk) -O3 main: # @main this seems to be a bug with LLVM backend. now, if you use gcc, you might end up with the process hogging as much cpu as it can. so you really should sleep there.

man this is complicated

AI ART LMFAO

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.

Still too complicated for me

Busy waiting for a signal???

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()]

ngl it felt cool didnt understand anything

why use AI for the thumbnail?

what's the point of those strange characterisations, such as "the kernel VERY CAREFULLY saves all the registers..."? Why not just say "saves" instead? It's an inanimate abstract interface, it's unable to CARE. I get it that you're trying to make it sound like a story from a book for kids (or something), but this just doesn't sound good.

Thanks!