Coding My First Linux Kernel Driver in C (Beginner)

Added: 2026-05-09

[00:00:00]Hello everybody. In today's video, we're going to code a What a boring intro. We're going to code a kernel driver. That's actually quite interesting. And the funny part is I haven't prepared this video at all. The only thing I have done is I've looked up kernel driver hello world on Google and found this result. I haven't clicked on it yet. Hello world part one the simplest module. That sounds quite promising. And maybe we're going to use that to create our own kernel driver in C.

[00:00:35]And just as a disclaimer, I haven't prepared prepared this video. I have never dealt with kernel drivers. I have never programmed anything related to kernel drivers. I haven't even I haven't programmed a kernel driver itself.

[00:00:52]So, this is just me trying to learn something new. All right. And maybe it's interesting for you to follow along.

[00:01:00]And learn along with me.

[00:01:03]And all the kernel driver pros, please put whatever you find deserves correction in the comments as always.

[00:01:15]And let's make this a great learning experience.

[00:01:19]So, hello world part one the simplest module. This is a hello world kernel module programming guide on the Linux documentation project which is a project that attempts to document a lot of things in Linux.

[00:01:38]>> [snorts] >> And we're going to use that.

[00:01:40]So, the kernel module is I think the same thing as a kernel driver.

[00:01:48]No idea. Is a kernel module a driver?

[00:01:53]Maybe a kernel module that's my first um idea. Maybe kernel module is just a generic piece of software that runs in kernel mode. So, it's not um part of the user system.

[00:02:10]And a driver is a specific kernel module. So, a piece of software that runs inside the kernel that interacts with hardware. So, that is a specific kind of kernel module.

[00:02:25]Oh, and there's even a definition here.

[00:02:28]A kernel driver is a program kernel module that is designed to drive a piece of hardware. Yeah. I think that's what I just said. Did I say it? I think so. So, a kernel driver is a kernel module that is designed to drive a piece of hardware.

[00:02:44]All right. Since I don't have any hardware any interesting hardware with me right here right now, we're going to just create a simple module and I think this example is exactly what we want.

[00:02:59]So, when the first caveman programmer chiseled the first program on the walls of the first cave computer, it was a program to paint the string hello world in antelope pictures.

[00:03:10]>> [laughter] >> Uh that Okay, I already like this documentation by the first sentence. Um there's this documentation this kind of documentation that is overly extensive and nobody really understands it and nobody reads it and just skips to the code examples. And then there's this kind of documentation. I can follow this. This is nice.

[00:03:30]Roman programming textbooks begin with the salute mundi program.

[00:03:37]Uh that's probably hello world. I don't know what happens to people who break with this tradition, but I think it's safer to not not to find out. We'll start with a series of hello world programs that demonstrate the different aspects of the basic basics of writing a kernel module. Okay.

[00:03:58]Here is the simplest module. Don't compile it yet. We'll cover module compilation in the next section. Hello world.

[00:04:08]And I would say let's recreate this hello world.

[00:04:14]And inspect the individual lines of code here. So, what I can already see is we have two includes here module and kernel. Oh, that's that's interesting. Of course, because we want to in We want to create a kernel module. So, of course, we we include kernel and module.

[00:04:33]>> [laughter] >> If you want to create a hello world, you of course include hello and world. And if you want to create a a cryptocurrency, you include crypto and currency. That's how programming works, guys. That's what That's what you study for 5 years at university for.

[00:04:53]So, include kernel and module. I can do that. Let's try and see. So, include kernel.

[00:05:02]No, I already messed up. Linux/kernel.

[00:05:05]And include linux/module.h.

[00:05:14]Those are probably headers that contain the methods that we need. Maybe it makes sense to open or try to find those headers.

[00:05:22]If I switch here to user local lib, I don't know if they are if they are located in local lib or in somewhere else because local lib is it's just local to Is it local to my user?

[00:05:37]Or is it user space libraries maybe?

[00:05:41]I'm just guessing, guys. If I try to find kernel.h, it's not found. So, I don't think that's what we need. Maybe it's somewhere else. I'm just going to search in user.

[00:05:52]Okay, there are a couple of files here that look like matches. I think this is the match. Include user include linux kernel. Okay, so it's not inside user local lib or user local include. It's in user include linux kernel.

[00:06:15]And then let's get the real path of this. This returns the absolute path of this result here. So, now we have an absolute path and then we can open that one in them using using tab e.

[00:06:29]And there's nothing in here. Oh, great.

[00:06:32]It's just a header including something else.

[00:06:35]Okay, fine. So, there's not much information here except if we really want to dig deeper then we have to open other header header files.

[00:06:44]And the other thing that we wanted to check is module.h.

[00:06:50]And there it is. And now I messed up my layout. Great.

[00:06:55]So, let me just fix it for a second.

[00:06:59]And there we are. Okay.

[00:07:03]So, let me just grab that absolute path here and open it here. And this is the module.h file. And again, it's just What is it even doing? It's just defining linux model module.h.

[00:07:19]And then it's defining a couple of flags here for the sysf_init_module, whatever that is. And then ending it already. That's the entire header file.

[00:07:35]That's I I expected it to be more complex than that. Honestly. But maybe I'm looking at at um at some stops that are not used. I don't know. If you know it, then please put it in the comments, guys.

[00:07:52]So, now that we have included the header files that we need, let's have a look at the hello world example again. And this one makes sense. Okay, we want to create a module something that runs as part of the kernel or rather in kernel space.

[00:08:12]We have to initialize the module. That makes sense. That is something that I can intuitively understand.

[00:08:17]So, if we do int, that's probably a return return type or return value for the success of of this module.

[00:08:30]And then init_module init_module takes in no arguments. So, we don't even need to specify void there, I think.

[00:08:41]Then there's a function printk which uses a macro kern_info.

[00:08:48]And then a string is printed.

[00:08:52]Okay.

[00:08:55]That's an interesting syntax. I have never seen this combination of a print command with a macro inside the argument.

[00:09:05]And then the macro takes as argument this string argument and then probably does something with it. I don't know.

[00:09:14]Macros are always magic to me. I have never I never understand how they really work.

[00:09:19]Um of course, macros are simple string substitution. So, this kern_info thing right here, this will be looked up by the compiler somewhere.

[00:09:30]And there will be some string substitution being made in the code. Of course, this can be arbitrarily complex and that's why it's natural to not have an intuitive grasp of macros because macros escape the normal C syntax and they completely break through it all. They are basically unlimited. You can do whatever you want with macros as far as I know.

[00:09:56]So, we just And since the these are things that you can't derive from from your own brain.

[00:10:06]Right? This is information that you can't think up naturally yourself. You can't come up with this yourself. This is stuff that you have to look up and that's why you need to follow some guide.

[00:10:18]Right? So, it's technically it's impossible to make a tutorial on a kernel driver programming.

[00:10:27]Yeah, it's impossible to make a tutorial about kernel driver programming without having looked up code before because there were some people in the comments complaining that probably the code that I'm showing you guys is not made up by me.

[00:10:44]Um and of course in such examples here it's impossible to make it up yourself.

[00:10:52]Because this is something that some develop- developer has arbitrarily decided and then you just have to follow this pattern.

[00:11:00]So, let's just follow the pattern and look things up along the way. So, we're going to print K. I assume it's then for print kernel.

[00:11:10]So, print K. There's no auto suggestion currently possible because Vim is not aware of that prototype.

[00:11:19]Print K then kern_info kern_info And I would actually like auto completion in Vim. So, what I could do is here in user include I could rip grep for print K.

[00:11:40]And let's see if we can find anything.

[00:11:43]And there are a couple of results here.

[00:11:48]Um I don't know if anything is an exact match. sysctl lp Those looks Those definitely look like some driver file files. atm_eni I don't know.

[00:12:07]But there's no method prototype for print K itself.

[00:12:12]Maybe [clears throat] the kernel headers are located somewhere differently and we can find this out later.

[00:12:19]So, print K kern_info and then we just type hello world.

[00:12:32]Ah, that's too boring. Let's make it super exciting and print hello Daniel.

[00:12:36]That's how you write an exciting software.

[00:12:40]Huh, heart rate is raising.

[00:12:43]Okay.

[00:12:45]And then a non-zero return means init module failed and that's what I already assumed by the int return value. That's only used to indicate an error and in this example it's just it's always returning zero. So, return zero.

[00:13:05]And what's the next thing? We clean up the module.

[00:13:09]And that's just another message that is being printed here. So, let's just do that as well, but I think technically we could also leave the cleanup function which is returning void. We could probably leave the function body empty. It's just nice to see um the interaction with module loading and unloading, I think.

[00:13:33]So, I think when we load the mon- module, the init module will run and when we unload the module the cleanup function will run. So, let's see. Print K kern_info again kern info and bye-bye.

[00:13:59]Love you.

[00:14:02]Ah, yeah.

[00:14:04]Okay. So, someone's Ah, [gasps and sighs] someone's nice to me.

[00:14:10]Intimate relationships with kernel drivers, guys.

[00:14:12]That's how you do it.

[00:14:15]So, Okay, kernel modules must have at least two functions. Okay, we've already found that out. I probably um found out about about all of these things myself um just by talking right now.

[00:14:29]Um typically init module either registers a handler blah blah blah blah blah blah blah blah blah.

[00:14:35]The cleanup module function is supposed to undo whatever init module did so the module can be unloaded safely. Aha, okay.

[00:14:44]Fine. We don't need that right now.

[00:14:50]And then lastly every kernel module needs to include linux/module.h.

[00:14:56]We needed to include linux/kernel.h only for macro expansion for the print K log level kern_alert which you learn about in section 2.1.1.

[00:15:06]Aha, so this right here is a log level.

[00:15:10]Ah, and I put a typo here. There should be no comma as far There should be no comma as far as I understood.

[00:15:23]Aha, this is interesting. So, log levels can be provided here as macros.

[00:15:29]So, introducing print K. Despite what you might think, print K was not meant to communicate information to the user even though we use it for exactly this purpose in hello in the hello world program it happens to be a logging mechanism for the kernel and is used to log information or give warnings. Therefore, each print K statement comes with a priority which is the one and kern_alert you see. Wait, which one?

[00:15:58]Is this one in the string? Is this mandatory?

[00:16:02]I thought I can just skip it.

[00:16:06]Wait.

[00:16:07]With which is the one and kern_alert you see. Where do I see a kern_alert? I just see kern_info.

[00:16:13]kern_alert Hm.

[00:16:18]There are eight priorities and the kernel has macros for them. So, you don't have to use cryptic numbers and you can view them and their meanings in linux/kernel.h.

[00:16:28]I can't view anything in linux/kernel.h, but maybe in sysinfo. Maybe or maybe in const.h. So, let's open the current directory const.h. Maybe there's something in here and if we look for kern kern_info.

[00:16:51]There is nothing in here. kern_info.

[00:16:54]Okay, there's nothing in here. Maybe let's check the other file. What was it called? sysinfo tab e sysinfo.header >> [gasps] >> And in here kern info is not included either. So, I don't get where these are defined. rip grep kern_info Mhm. Okay, there were some results here.

[00:17:34]Yeah, timeshift. No, that's not what I wanted.

[00:17:45]Where is Wait. linux/kernel.h location user include linux kernel.h is include is intended for user processes, not kernel modules.

[00:18:03]The print K priority macros now live in linux Where is it? priority macros now live in linux/printk.h.

[00:18:21]I'm guessing you're reading the original guide which is based on 2.6 kernel series. For modern kernels, you should read the updated guide. There's an updated guide?

[00:18:34]Which kernel am am I even using?

[00:18:39]Am I using something that is outdated?

[00:18:52]What if I search for printk.h as this guy here indicated? printk.h Let's have a look there.

[00:19:08]CD user include print f Ah, no. What am I doing?

[00:19:19]FD print K There's nothing here.

[00:19:27]There's a printk.h. There are several printk.h's.

[00:19:34]These are source files.

[00:19:38]lib/modules I don't know. This does not look like clean paths that are used that are supposed to be used to me.

[00:20:01]Anyways, I'm just going to try to follow the guide here and not question it too much because as soon as I start questioning questioning things things start falling apart.

[00:20:14]And I think we should try to compile this first and see if it even works before I try to question things here.

[00:20:24]So, introducing printk and printk well, actually should be defined somewhere here.

[00:20:33]And there is a lot of stuff referencing printk, but I don't know which one is the correct one and that's always that's always annoying.

[00:20:43]user include rip grep printk What's in here?

[00:21:04]Does not look like printk is available on my system at all.

[00:21:12]Take time to read through the priority macros. Yeah, but how where the hell are they?

[00:21:19]I'm going to find them guys. I'm going to not give up. kern info where is it?

[00:21:29]Wait, what if I pipe this into less and carefully read it?

[00:21:32]So, this looks like we could find something.

[00:21:40]This is all On the other hand, all of this looks like these are these source paths starting with source.

[00:21:56]So, they don't look like they are what I'm looking for.

[00:22:04]But this one is using printk with kern info.

[00:22:08]So, if I'm looking up this file, uh where is it?

[00:22:18]Uh let's for example this one.

[00:22:21]What is it including?

[00:22:32]keys trusted type Mhm.

[00:22:38]Maybe my Linux works without a kernel.

[00:22:45]Maybe my Linux distribution works without a kernel. Yeah, and that could be the case. So, mine is a kernel-less driver. Just like you have uh you sometimes have fruit without kernels. Is Is kernel even the right mhm term in English?

[00:23:04]kern English core Yeah, kernel.

[00:23:12]Mhm.

[00:23:14]Yeah, it's just like the stone in a cherry.

[00:23:16]There are cherries without stones inside them.

[00:23:20]So, probably my Linux also kernel-less.

[00:23:27]I'm really milking the joke.

[00:23:28]I've repeated it three times already.

[00:23:31]So, a kernel module Wait.

[00:23:38]Where do I find kern info?

[00:23:47]kern levels.h kern levels.h Is that it?

[00:23:54]find kern levels There it is.

[00:23:59]But this is also in these source directories. I thought this is What is this even? Linux HWE What does this stand for?

[00:24:13]Linux HWE hardware enablement >> [sighs and gasps] >> Server installations will default to the general availability kernel and provide the hardware enablement kernel as optional.

[00:24:29]I don't want I just want the regular one.

[00:24:40]Linux kernel headers Where?

[00:24:47]I don't have them Do I have to install them maybe first?

[00:24:51]Linux Linux install kernel headers If I have to install them all and that that would be the explanation. You should be able to install the kernel header files for the currently running kernel by running the following in a terminal.

[00:25:11]Okay, sudo apt get install Linux headers.

[00:25:14]What is uname -r? I think I I saw that somewhere that is I think operating system info.

[00:25:22]Uh What is that 617?

[00:25:27]Is that my kernel version?

[00:25:29]R is the kernel release. Okay, so that's the kernel release.

[00:25:35]And if I do this, and this is an answer from 2011. I hope it's still up to date, guys. Otherwise, I will nuke my system probably.

[00:25:47]is already installed.

[00:25:53]But where?

[00:25:57]kernel headers generic if you are on a desktop installation.

[00:26:05]Is that maybe it?

[00:26:07]What's the difference between the generic one and the version specific one?

[00:26:12]I hear someone complain this won't install the headers for future updates automatically.

[00:26:17]Ah, okay.

[00:26:20]Mhm.

[00:26:32]So, now it's it's building a module. What the hell is going on?

[00:26:37]I hear my processor my processor spinning up.

[00:26:42]I hope nothing is exploding.

[00:26:50]Am I installing something critical down No, I What did I just install? Linux headers generic.

[00:26:57]Mhm. So, Linux headers generic. Okay, that should be uh that should just be header files, but it was a 100 megabytes.

[00:27:07]>> [snorts] >> Whatever.

[00:27:10]So, let's try to find the kern info now.

[00:27:14]It's still not there.

[00:27:16]kern info But then there are headers for this specific kernel version that I have installed that we just found out using uname -r.

[00:27:38]Although I have the -20 generic and this only lists -20. So, is there a difference between those? I don't know if there's a difference.

[00:27:51]But I Wait.

[00:27:53]Here the kern info is defined.

[00:27:59]Is it defined somewhere else? It's also defined here.

[00:28:05]And here.

[00:28:07]kern levels.h Wait, if I search for kern levels.h now, do I find something new?

[00:28:16]I think those are the same results I already had before.

[00:28:22]I don't know, guys. So, I know that I'm using this specific kernel release. So, I'm going I'm going to use this kernel header file here.

[00:28:35]Okay, let's not overcomplicate it. I am There are so many details to kernels um that I'm that I didn't really ever consider.

[00:28:45]For example, that there are different versions of the kernel.

[00:28:52]You can have multiple steps from multiple different kernel versions installed on your system.

[00:29:02]I don't know. I don't know if it's even included like that.

[00:29:06]But I Let's see. Let's just see.

[00:29:14]I mean, I don't know if it's included like that because the default include path is user include. So, anything under here will be found by the compiler.

[00:29:24]And anything under user local include will also be found.

[00:29:29]But the kernel headers were defined here in user source Linux blah blah blah blah blah.

[00:29:36]include Linux kernel driver We'll see how this will compile in the end. But so far, now with kern levels open we can at least find out something about the lock levels here.

[00:29:54]So we are using kernel info here. It's an informational log. It just is the string six.

[00:30:04]But then how the hell does the printk accept this string and this string without a comma in between them? This can only work if printk itself is some magic some black magic thing.

[00:30:19]So let's search for black magic printk here. printk and I assume Oh.

[00:30:32]I I just thought printk is defined as printf here. printf is just printk. What is that?

[00:30:43]void printk maybe maybe there's something about that.

[00:30:55]So okay.

[00:30:57]I'm just going to accept printk for now.

[00:31:01]Let's not question too much. I found that whenever you question things it's an incredible an incredible slowdown.

[00:31:07]I think this documentation here said that printk was a macro and therefore you can expect some magic to happen.

[00:31:15]>> [sighs] >> If the priority is less than console log level the message is printed on your current terminal. If both blah blah blah. Okay, that's boring. We don't need that. I want some kernel stuff to happen now.

[00:31:29]What do we even expect to happen? Do we just expect a message to be printed to the console?

[00:31:34]Compiling kernel modules. Oh.

[00:31:37]Ah, right. Because if everything is correct now then this is a minimal kernel module.

[00:31:45]And now there's a section on compiling kernel modules.

[00:31:49]Kernel modules need to be compiled a bit differently from regular user space apps. Okay, so we can't use the the glorious GCC compiler.

[00:32:00]We have to use something else. So former kernel versions required us to care much about these settings which are usually stored in makefiles although hierarchically hierarchically organized many redundant settings accumulated in sublevel makefiles and made them large and rather difficult to maintain.

[00:32:22]Fortunately there's a new way of doing these things called Kbuild.

[00:32:26]Oh.

[00:32:30]And the build process for external loadable modules is now fully integrated into the standard kernel build mechanism. So as I said I suspected that there's a dedicated build mechanism for kernel modules. You can't just compile them yourself somehow or maybe probably you can compile them somehow yourselves but it you need to um account for many settings and flags and the likelihood that you mess up is incredibly big.

[00:33:01]And maybe if you know exactly why then put it in the comments. If you know why kernel level modules need to be compiled using a kernel build mechanism. So what's the core difference between kernel level modules and user space apps?

[00:33:22]That would be interesting to find out about.

[00:33:26]But of course on the application level one runs in user space the other one runs in kernel space. Fine. But I mean from a software standpoint.

[00:33:36]To me as a programmer both are just code running somewhere. There's no difference.

[00:33:41]To learn more on how to compile modules which are not part of the official kernel such as all the examples you find in this guide see Linux documentation Kbuild modules.

[00:33:58]So let's look at a simple makefile for compiling a module called hello.c.

[00:34:04]This is a makefile right here. I have also never really used makefiles except in absolute emergencies and never without instruction.

[00:34:16]I don't get them. So we're going to create a makefile for a basic kernel module. From a technical point of view just the first line is really necessary.

[00:34:27]The all and clean targets were added for pure convenience.

[00:34:36]Now you can compile the module by issuing the compile command make. You should obtain an output which resembles the following.

[00:34:44]Okay.

[00:34:47]But I find it interesting that the documentation says that we have to use the new approach Kbuild and then this makefile does not even use Kbuild or does it?

[00:34:59]It uses it uses lib modules and the kernel module version probably.

[00:35:07]/build. Is that Kbuild? I don't know.

[00:35:11]Probably it is.

[00:35:14]So now with this makefile copied I'm just I'm not going to go over it term by term word by word as with the previous C source file just because I really cannot contribute any meaningful knowledge about makefiles here. They are horrible to me.

[00:35:36]So let's just copy it paste it here.

[00:35:39]Maybe here CD into the driver into the kernel driver directory.

[00:35:47]I think we should Am I located in the kernel driver directory?

[00:35:52]Wait.

[00:35:55]Yeah. Okay.

[00:35:58]So now we have two files here.

[00:36:04]driver.c and makefile and now according to this guide I can just do make.

[00:36:13]Oh.

[00:36:14]Okay. The kernel was built by GCC. Okay, so it used GCC under the hood.

[00:36:24]The compiler differs from the one used to build the kernel.

[00:36:29]The kernel was built by GCC.

[00:36:31]Okay.

[00:36:34]It created a file hello.o which is a compiled file. I don't see any file in the current directory so maybe it was put somewhere else now.

[00:36:48]I think probably the file was moved somewhere because here it's leaving the directory.

[00:36:55]Oh, then it's encountering an error and another error in line four.

[00:37:01]And line 248 wait. That's not my makefile.

[00:37:06]So is this now a success or is it an error? The last line indicates error which is not too great.

[00:37:21]Note that kernel 2.6 introduces a new file naming convention. Kernel modules now have a.ko extension in place of the old.o extension which easily distinguishes them from conventional object files. Okay, the reason for this is that they contain an additional modinfo section at where it that where additional information about the module is kept.

[00:37:49]Okay, but Okay, I assume for me the compilation just didn't work because there's an error here. So what's the error?

[00:37:58]The documentation said that the all section is not even necessary but I can't imagine this makefile doing anything meaningful without the all section. And the all section is I think what causes the error because it says makefile colon four which is this line right here which is erroneous.

[00:38:25]So what's wrong?

[00:38:28]Leaving directory.

[00:38:30]Hm.

[00:38:34]No rule to make target hello.1.o.

[00:38:38]Ah.

[00:38:40]Of course the source file has the wrong name. I just copied this makefile blindly and hello.1.o should maybe be driver.o because my source file is called driver.c.

[00:38:55]And the error message is complaining about no source to create no rule to make target hello. 1.o needed by Ah, no maybe that's not an error. But it's definitely one thing that would surprise me here. Um I will just retry.

[00:39:16]I don't think that's the exact error but it also didn't look too healthy.

[00:39:25]Now something else happened.

[00:39:29]modpost simvers missing module license in driver.o. Did we create a file? Now something happened. Okay, now something happened guys. We have the C file which we created. Then we have a dot mod file, a dot O file, and a modules.order file. There's still an error.

[00:39:49]What's the error?

[00:39:50]But did it not compile? Well, because I'm encountering an error here, but I still have a compiled object file here.

[00:40:02]And maybe since Mhm. Since I have a kernel that is higher release than 2.6, I have to call them file.ko instead.

[00:40:22]>> [snorts] >> I don't trust this thing.

[00:40:32]So, let's have a look at the make file in in a bit more detail because it just a couple of minutes ago it proved to be the source of the first issue.

[00:40:41]So, we make -C. Okay, we probably provide a file to another make file, which is this build thing.

[00:40:54]And we pass the current directory into it.

[00:41:02]Ah.

[00:41:03]driver.o Or maybe it's this a It would be a good idea to uh >> [groaning] >> to search for an error. So, the first error that we get here is error on modpost missing module license in driver.o.

[00:41:25]So, I'm going to search for error modpost.

[00:41:32]Error one.

[00:41:34]Okay, let's search for this error, guys.

[00:41:41]Here.

[00:41:42]My Linux kernel driver contains module license, but during compilation following warnings printed blah blah blah. This makefile was incorrect. The module name was equal the source file name.

[00:41:57]The following works. mymodule.o before mymodule.o my module why?

[00:42:12]So, it has to do with naming, maybe.

[00:42:16]>> [sighs and gasps] >> I had to add module license at the end of my module.c file and it worked.

[00:42:23]See also this GitHub issue.

[00:42:39]That's interesting. So, this seems to be an issue quite a few people seem to have.

[00:42:47]Although it's still quite opaque to me what the nature of this of this issue is.

[00:42:53]Missing module license in driver.o.

[00:43:15]I didn't know that the source file should have the same name specified by object M.

[00:43:21]After renaming the file to helloaxso.c, everything worked. Okay, we also had this regarding the make file.

[00:43:29]Uh Of course, now the make all requires sudo to install the module. Do we even install here?

[00:43:41]What if I compile this with sudo now?

[00:43:45]Is that the issue, maybe?

[00:43:48]sudo make This one looks different again.

[00:44:01]bin shell flex not found No such file or directory.

[00:44:12]But indeed it it uses the user source Linux headers blah blah blah directory.

[00:44:18]It tries to, at least.

[00:44:20]And it doesn't find files. Deleted file here.

[00:44:29]Interesting.

[00:44:30]It's interesting how opaque problems look if you have no idea what they are.

[00:44:42]The error shouldn't matter. Just do this, this, this. The error shouldn't matter.

[00:44:49]Okay, wait. The error shouldn't matter.

[00:44:51]That's a good indicator. So, I have a a compiled object file. Good. The error shouldn't matter. What if the error just What if we can just ignore them the error?

[00:45:02]So, if we just ignore the error, then I have a second to have a sip of water.

[00:45:16]And then lots of useful information you see here.

[00:45:23]Where Where do we see useful information?

[00:45:25]We see useful information if we do make and then modinfo. Ah.

[00:45:33]Wait. modinfo driver.o Why does this guy Why is he able to do modinfo on his compiled file and I'm not?

[00:45:52]Maybe it's not called driver.ko in the kernel. No.

[00:46:01]modinfo modinfo modinfo help. What does this do?

[00:46:15]man modinfo Show information about a Linux kernel module. modinfo extracts information from the Linux kernel modules given on the command line.

[00:46:27]If the module name is not a file name, then the directory searched.

[00:46:35]>> [gasps] >> So, I can just specify a file name.

[00:46:40]And the file is available here at driver.o.

[00:46:46]So, modinfo driver.o should work.

[00:46:50]driver.o not found. Are you stupid? It's in this directory. I just gave you the path.

[00:46:55]>> [sighs] >> Now you can compile the module by issuing the command make.

[00:47:12]You should obtain an output which resembles the following.

[00:47:17]But I don't have a KO file. So, maybe that's maybe that's an effect of the error that I don't get a.ko file.

[00:47:29]Why do I get a different output every time I execute this?

[00:47:33]>> [laughter] >> So, flex not found flex not found kernel module flex not found kernel kernel module flex not found Open a terminal control alt T sudo I into blah blah blah. Delete its contents.

[00:48:06]No.

[00:48:11]What is flex?

[00:48:14]sudo apt install flex. If it's not found, I'm just going to install it, whatever it is.

[00:48:21]And now I can probably install it.

[00:48:23]bison not found. What What What are those programs?

[00:48:27]Okay, then let's install bison.

[00:48:32]>> [laughter] >> What's not Now it's doing something.

[00:48:37]Oh, it's What the hell was that? I just installed things that sounded like I need to install them.

[00:48:49]So, what do I need to do now?

[00:48:51]proxy execution Yes, no?

[00:48:57]I have no idea what that is. Restarting configuration. I'm just going to hit yes.

[00:49:02]Um And now I get another error. Okay.

[00:49:06]So, it's the rule of confidence. As soon as you get confident about anything in programming, you get an error.

[00:49:13]And that's because I just sensed a hint, just a shade of joy because it looked like it's compiling here.

[00:49:25]The second the universe sensed that I was joyful, it threw me an error.

[00:49:32]So now, no rule to make target awk as needed by include generated ASM CPU feature masks. Stop.

[00:49:46]I make What's even the point of kernel programming? Well, this is And now I do sudo make and the the error is the log is again different.

[00:50:01]CPU feature masks AWK I'm just going to search for this error here.

[00:50:13]Do I Wait, I didn't even check if I need to install any dependencies before compiling the kernel. Which dependencies for or which requirements for compiling kernel module in Linux?

[00:50:31]Build essential, okay. Kernel headers, okay, I do have them now.

[00:50:38]Makefile No, all of this looks okay.

[00:50:48]Compile and make to generate the KO file.

[00:50:51]And then we insert the module.

[00:50:55]Uh You need build essential and kernel headers.

[00:51:06]I have them all.

[00:51:08]If I do make, it doesn't work. No rule to make target.

[00:51:14]Well, then just compile without a rule.

[00:51:20]I mean what? I mean it's it's literally just a single printed message from the from the kernel module.

[00:51:34]>> [snorts] >> So, let's check here.

[00:51:39]In the makefile, just change subdirectories into shell PWD.

[00:51:49]Why?

[00:52:07]So, here it's trying to access the current directory.

[00:52:11]PWD is the current directory that the makefile is executed from, that's my understanding.

[00:52:18]>> [gasps] >> Maybe we have to replace it, but then why? Why doesn't it work?

[00:52:36]Works like a charm. Okay, I'm just going to replace it with PWD.

[00:52:44]So, here shell PWD.

[00:52:56]Shell PWD, is that correct?

[00:53:00]It is correct, then let's try to sudo make.

[00:53:06]Error.

[00:53:14]Missing module license in driver.o. So, we're back to the first error that I thought it was solved by compiling with sudo make.

[00:53:27]Missing module license.

[00:53:40]You need to add a call to module license to your source file hello.c in your case. This is what the error message is talking about. Why does it need this license thing?

[00:53:54]Okay, I'm just going to do it.

[00:53:56]Not question things. Don't question stuff.

[00:54:00]Just do what the kernel people are telling you to do. Be a slave to the kernel people.

[00:54:08]No wonder that if you're a kernel programmer, you are so unhappy in your life.

[00:54:12]Um Regular programmers are much happier.

[00:54:19]Uh So, where do I put it? Where do I put this um module license thing?

[00:54:35]Maybe up here.

[00:54:38]Module license GPL No idea what that license is. No idea what anything is. What is GPL license?

[00:54:45]GPL license Most widely used free software license.

[00:54:53]Can I just give it my own license? Let's try and see.

[00:55:02]And this worked. Okay, so with a Daniel license solved it. So, guys, this is the official I'm the official kernel compilation authority. Just put module license Daniel in your code. Another string won't work, by the way. It's only Daniel that works.

[00:55:20]And then you do Now we have a couple of new files here, and now we can use modinfo to find out what driver.ko means or is. So, aha.

[00:55:36]This is a file. It has a license.

[00:55:42]I love the license. So, Daniel's magic license. And by the way, I'm putting arbitrary strings in here to show that this this is meaningful meaningless information. It's just some string that someone wanted to be filled, but it's not technically necessary to do anything.

[00:56:07]Module description. Ah, I can also put a description there. So, let's also put a description.

[00:56:15]Interesting that the license is not mandatory.

[00:56:18]This is the most elaborate kernel driver that has ever been devised.

[00:56:30]Pure art.

[00:56:34]Okay, and now if we compile this most elaborate kernel level driver or kernel driver, we get the file driver.ko, which is the kernel object file. We do a modinfo driver.ko, and now we see the license here.

[00:56:57]Daniel's magic license and the another license. Oh, that's because I messed up and put two module license in here. Of course, that's wrong. It needs to be module description.

[00:57:12]Description. That is a crazy This one is a crazy episode, by the way, because I'm really I'm only airing forward, and I can already smell the comments again.

[00:57:23]Um from from some guys um complaining that I just try out stuff, and um I have no clue what I'm doing, and I'm just creating errors and looking up stuff, and then uh and it's horrible to watch me, but this is how I learn. And I just record videos about this stuff.

[00:57:41]This is how I started. The last couple of videos were more um edited.

[00:57:47]I tried to make them a bit faster, a bit more um adapted to the algorithm, but it really sucks the joy out of video production for me. For me, I enjoy making videos if I can just hit record and do something here and learn something, because I'm not a teacher. Right, I'm or I never intended this channel like a as a tutorial channel. I just intended it to show the stuff I'm doing and to share my stupidity with the world.

[00:58:17]And I really mean it. I just wanted to show how you can do stuff with computers, how I do stuff with computers, and how you can look up things, and maybe along the way learn stuff.

[00:58:31]And if it takes some time, fine. If you have no idea what the errors mean, fine.

[00:58:37]If something interests you, if if there's a topic that interests you, and that sparks some some curiosity in you, then then you can go and read some theory and read books about that topic. But first, try to put your toes in dip your toes in all the different topics and find out a bit of about of all of them. And today we found out about the about the module API or even ABI here about the specific way kernel modules are compiled, about these licensing things there, these flags that need to be added. So, we kind of already built some basic knowledge, and the next time we we record something about kernel drivers, we're already better prepared. So, there's always value in airing forward.

[00:59:30]So, now let's check the module info and now there's this module here. This is the license, Daniel's magic license. This is the description that I just put in. This is the file name.

[00:59:46]Source version, okay, some hash probably.

[00:59:50]It's a driver.

[00:59:51]And this right here is the kernel it was compiled against probably.

[00:59:59]And now we can just close all these error investigation tabs and reopen the hello world kernel module guide. Let's skip forward to the compilation which we have now succeeded in. And now I think we can just load this kernel module somewhere. Wait.

[01:00:18]How is it loaded?

[01:00:22]Init module, no.

[01:00:25]Wait.

[01:00:29]So, here.

[01:00:32]Ah. [sighs] Wait, wait, wait. Let's have a look at what what else needs to be done here.

[01:00:47]So, here this guy does some some things. Again, no idea what those are.

[01:00:55]Let's skip forward. I want to find out how to how to load these kernel modules and where I can see anything that I did using them. Building modules for a precompiled kernel, blah, blah, blah, blah.

[01:01:13]Modules, programs.

[01:01:17]So much stuff here going on.

[01:01:23]Okay. How to load a kernel module in Linux.

[01:01:32]So, [snorts] here.

[01:01:35]Blog posts. Blog posts are always the most horrible source for anything.

[01:01:39]But sometimes you can find something valuable.

[01:01:44]Usually they are not very helpful.

[01:01:48]How can I load kernel modules on boot?

[01:01:51]No.

[01:01:52]A load.ko file.

[01:01:59]To load a.ko kernel object file in Linux, use sudo insmod for a specific file path or sudo modprobe to automatically handle dependencies.

[01:02:11]Verify loading with lsmod and remove with rmmod.

[01:02:17]Okay.

[01:02:19]So, now we can check using lsmod the active kernel modules. lsmod.

[01:02:32]There are a couple.

[01:02:38]And so, these are the kernel level modules that are running currently.

[01:02:48]Now, if I do sudo insmod driver.o invalid Ah, driver.ko of course. Invalid module format. Why?

[01:03:05]insmod file.ko >> [snorts] >> invalid [clears throat] module format insmod invalid module format. What's the error here?

[01:03:30]Kernel from which you built your kernel module and to which you are inserting module should be the same version. If you do not want to take care of this thing, you can use the following makefile.

[01:03:43]Well, that's exactly what I did.

[01:03:49]Or is it not?

[01:03:58]Now you can build and try to insert your module.

[01:04:11]You did everything correct, but you did not boot your system with the kernel you compile compiled. So, the first step you is you should boot with it. If you are using Ubuntu, you can hold shift button at the same time at the time of booting and you will be given a list of compiled kernels in your system.

[01:04:29]From there, select Linux source, blah, blah, blah, and then try to build your module and install it with your way.

[01:04:36]What?

[01:04:42]I'm just going to copy this sudo apt install thing here.

[01:04:48]Let's see if this helps me. 500 megabytes.

[01:04:53]What am I What am I even installing here? Linux headers?

[01:05:04]I don't even recall if I really changed my kernel at some point. It's possible that I at some point changed it.

[01:05:15]But overall, um I'm surprised it doesn't work.

[01:05:25]insmod invalid module format Module and kernel are not the same version. Sometimes you can get rid of this error if you didn't use the same compiler.

[01:05:47]Well, What have What have I done done wrong?

[01:05:51]In the makefile, I literally use uname -r to find the right version.

[01:05:58]And that's what's used to compile. So, what?

[01:06:02]Where did I Where did I go wrong?

[01:06:08]In your case, you recompiled the kernel and you didn't change rebuild initrd.

[01:06:20]Hm.

[01:06:23]Invalid module format error.

[01:06:54]It means that the file you are trying to load is not a valid kernel module.

[01:06:59]Either it never was or it has been corrupted or possibly it is for an architecture other than the one you have.

[01:07:07]Yeah, but I'm using this makefile.

[01:07:09]And it's using uname -r to find the current kernel version.

[01:07:17]uname -r Kernel system information. Let's check here.

[01:07:29]Yeah, Linux kernel 6.17 here. Generic.

[01:07:36]>> [sighs] [snorts] [snorts] >> Maybe after this refreshing here it works.

[01:08:21]Wait.

[01:08:22]What is Is this removing my graphics drivers?

[01:08:26]Nvidia?

[01:08:28]Oh, please don't. Please.

[01:08:31]Please, I just set up everything to work so nicely.

[01:08:51]Invalid module format when running a cross-compiled module. Yeah, but I'm I haven't cross-compiled.

[01:09:12]I have not cross-compiled.

[01:09:15]I'm just running. I have created the code on my machine. I've created the make makefile on my machine. I'm using uname -r to find the right kernel version.

[01:09:31]>> Yes, this path may be wrong. Let's check if it even exists.

[01:09:36]lib modules CT lib modules And there they are.

[01:09:47]And there are a couple of kernel kernel versions here.

[01:09:55]But why? Why are there a couple of kernel versions and why were they all refreshed right now?

[01:10:36]Am I right now changing my kernel version somehow? Building initial module for 617022 now.

[01:10:44]>> [laughter] >> What the hell did I just invoke?

[01:10:47]Yeah.

[01:10:48]Let me try to find out what I invoked.

[01:10:54]Here.

[01:10:55]apt upgrade apt remove Linux headers auto remove sudo apt auto clean. Okay, apt install Linux headers. It's just headers.

[01:11:06]So, it should be fine.

[01:11:08]This will reinstall the kernel headers.

[01:11:14]I tried to reinstall the headers. It didn't work, but purge is the key. I guess it worked.

[01:11:28]auto remove Go.

[01:11:32]Fast fast fast, let's go. Be faster. I'm in the middle of a recording and must be interesting at all times. I must serve the algorithm. I must retain everybody.

[01:12:00]>> [snorts] >> So, nice weather today, right?

[01:12:13]I hope you also have nice weather.

[01:12:16]For me, it's quite sunny.

[01:12:21]And now it's installed. Perfect.

[01:12:23]Um So, we can now list the modules. We can probably sudo make. Now we get another error. Kernel driver modules, no such file or directory.

[01:12:38]uname -r returns this.

[01:12:49]Maybe I need to create a new tab here.

[01:12:56]CD into the kernel driver then sudo make.

[01:13:06]Error.

[01:13:07]No such file or directory.

[01:13:12]But why Okay, so this apparently means that auto remove somehow removed the kernel that I'm not a and some Wait, I I don't even get what's going on here.

[01:13:28]So, auto remove removed or purged removed this directory.

[01:13:33]>> [gasps] >> And now I don't have it anymore, but which directories do I even have?

[01:13:37]lib modules If I list them there it is.

[01:13:44]617020 So, this should exist or the file under it doesn't exist.

[01:14:02]022 generic No, 20. It was 20 generic.

[01:14:10]And there is no built in here. What if we search for built?

[01:14:16]68100 10 built So, there's only one built file, but we're searching for other Wait, we're searching for another built file.

[01:14:32]Why does Wait.

[01:14:35]kernel install built tools Yeah, kernel header header files. Okay, fine.

[01:14:46]Linux headers uname -r Okay, install.

[01:15:02]And now I have the right built tool.

[01:15:05]Now it's here.

[01:15:08]I don't know why it only installed this one before.

[01:15:13]>> [snorts] >> But my system definitely uses the 617 kernel.

[01:15:21]Oh my god, this really drives one crazy.

[01:15:26]And now if I do sudo make did it work?

[01:15:37]It maybe it worked, yes. And then I do modinfo driver.ko.

[01:15:43]This worked.

[01:15:46]And now I can do insmod mod driver.ko.

[01:15:53]Could not insert module driver.ko.

[01:15:56]insmod help kmod version 31 >> [sighs] >> insmod >> [snorts] >> Could not insert module driver.ko.

[01:16:17]Could not insert module driver.

[01:16:25]module Could not insert module.

[01:16:41]You need to disable secure boot.

[01:16:45]Run the insmod command via sudo. Okay, I'm doing that.

[01:16:49]You need to disable secure boot.

[01:17:07]Alternative ways to disable secure boot using mokutil.

[01:17:21]>> [sighs] >> This is ridiculous, guys. So, how do I create a signed driver now? Do I need to sign insmod sign kernel module.

[01:18:38]Disable secure boot. Everybody says disable secure boot.

[01:18:48]Insert kernel module without secure boot.

[01:19:16]Generate a machine owner key pair.

[01:19:27]>> Oh gosh.

[01:19:29]So in any case, I need to reboot.

[01:20:07]But I don't get a signature error. I just get this invalid module format. So I don't think Maybe I'm just Maybe I've just looked too far.

[01:20:19]So it's the format that is an issue, not the key or a signature.

[01:20:27]I can inspect the output of dmesg after a failed insmod.

[01:20:32]So let's again try to do this and then dmesg.

[01:20:40]API mismatch. The client NVIDIA settings has the version this, but this kernel module has the version this.

[01:20:56]This is not related.

[01:21:03]Invalid relocation target.

[01:21:12]Invalid relocation target.

[01:21:34]I'm going to do a restart and see if it works afterward. I have the feeling I just need to do a restart for some reason.

[01:21:41]So after I think four or five restarts dealing with some kernel versions, I discovered the following. Well, the first restart I did After the first restart I did, let me just show you what the version of my kernel suddenly was. It was suddenly 6.17.0-22.

[01:22:00]So suddenly the version of my kernel changed. That's probably because I installed something some kernel header or I don't know what that changed the kernel version and that's what yielded the results the error that we saw. We compiled with this with the old -20 version, but under the hood somehow my kernel driver was my kernel release was already replaced and that's what caused the error.

[01:22:28]So now if I do uh if I do Here I used Claude to help me figure out all the driver issues. Let me close that. I don't need that anymore.

[01:22:47]So now we have the driver. It's compiled.

[01:22:54]However, it's compiled against an old kernel version. So we have to redo the release like this. Now I entered the wrong password. Let's do it again.

[01:23:08]Now this looks good. Perfect.

[01:23:12]I don't see any error here.

[01:23:14]If I now do sudo ins mod kernel uh driver.ko it works.

[01:23:27]Okay. And now what was the remaining procedure? Now the the kernel module is somehow installed.

[01:23:37]insmod. Let me just Let me just try to find it. Um What did we search for earlier?

[01:23:45]insmod kernel module.

[01:23:51]Compile and insert kernel module.

[01:23:57]How do I How to load a kernel module? Right, that's what I searched for.

[01:24:06]And then in this guide did I find anything useful?

[01:24:12]All right, we encountered the ls mod command, which we also used. By the way, the all the restarting and all the figuring out of all the versioning and driver issues and it took forever. So that's why I've already forgot everything again. Uh even OBS, the recording software that I'm using right now didn't work because of NVIDIA driver changes and I had to reinstall the the graphics driver and then my monitor didn't work and then I restarted again and then I installed a different driver and then it didn't work yet again and then I had to again reinstall everything. I It was horrible.

[01:24:45]So I'm glad my computer is still running.

[01:24:50]So lsmod.

[01:24:53]Is my driver now running?

[01:24:57]Do I find it anywhere here?

[01:25:00]It's just called driver, right? My kernel It could be my module. The size is 12,288 bytes. Does it make sense? Is it that one?

[01:25:16]Oh no, I don't know. No, no, no. Maybe it's not it.

[01:25:21]Although it is called driver.c, so I would expect it to be that.

[01:25:27]What if I use modinfo on the driver?

[01:25:31]driver.ko The name is driver. So it might be It might be that.

[01:25:40]So it might If I do this lsmod grep driver, then that's the only one.

[01:25:49]But how do I now see because the magic thing that we did here was when we initialized the kernel module, we printed something.

[01:25:58]But where do I see that log?

[01:26:02]modprobe Mm.

[01:26:06]No.

[01:26:12]etsy modules There needs to be something somewhere.

[01:26:18]So see kernel module logs.

[01:26:23]How to view Linux kernel logs?

[01:26:26]Maybe that's it.

[01:26:29]dmesg dmesg And there it is, guys.

[01:26:36]>> [laughter] >> Yes.

[01:26:39]There it is. Hello Daniel.

[01:26:42]Ah, that's So we really loaded our own driver. It doesn't do anything. It's completely useless, but we managed to do it. We managed to load our own driver.

[01:26:53]So here really fancy elaborate drivers do their thing, WireGuard, USB drivers, fancy things and then there's the real end boss driver that prints hello Daniel.

[01:27:08]>> [laughter] >> This is awesome. Nice. And then probably to trigger the other call. So what we're seeing right now is this init module call right here. And now I want to see the cleanup module call, which prints bye-bye, love you because it's such an empathic, loving driver. So let's see how do we do it? Unload kernel module.

[01:27:33]rmmod. Okay. sudo rmmod and then Do I just pass the module name? Okay, driver.

[01:27:41]By the way, driver is a really, really risky module name. It can conflict so easily.

[01:27:46]Let's try and see.

[01:27:48]I removed it and if I look at the kernel messages again, bye-bye, love you. Ah. [sighs and gasps] Guys, this was so awesome. This was a horrible episode um for my stress levels because >> [laughter] >> because of all the restarts and all the versioning conflicts and everything and under the hood or actually it should all be so simple. It's just this piece of C code and we load it as a kernel module, but the compilation and everything was ridiculously hard for me because I'm I like to mess things up.

[01:28:23]Um but it was fun. It's It's awesome to see the the module being active and loaded inside the kernel.

[01:28:32]That's awesome. That's the first time I've ever done this. So please excuse me for all the difficulties encountered in this episode.

[01:28:40]If you want to learn >> [laughter] >> It's funny to make an advertisement now.

[01:28:46]Um if you want to learn C programming the way I do it, not this type of C coding, but user space programming, graphics, all the useful programs, um then have a look at the No Nonsense C Programming Course.

[01:28:58]It's a course that I created. It's linked in the video description below the video.

[01:29:04]It teaches you C from a very practical perspective and teaches you some raylib basics, how to deal with libraries, how to compile user programs, so real programs that you will use in the end.

[01:29:19]And then a couple of mental models that will really benefit you in the long run as an engineer.

[01:29:27]Uh and they are mental models about how I think as a programmer to solve problems at etc. All right.

[01:29:36]Let's not talk too much. I hope you have a good rest of the day.

[01:29:40]And I hope you spark the discussion in the comments.

[01:29:44]And tell me everything where I went wrong, how I could make things easier, and maybe now because this hurdle is overcome, what's the next thing that I can do?

[01:29:56]The next kernel level thing that I can do or driver. Can I do something else here now with this as a basic framework?

[01:30:03]Because now I know how to how to write a very very very basic kernel module and compile it and load it.

[01:30:10]So all the all the formalities are overcome, but now we can do the interesting stuff. So put put any ideas in the comments.

[01:30:20]Thanks, and see you next time. Bye-bye.