{"id":7199,"date":"2022-02-08T11:21:11","date_gmt":"2022-02-08T11:21:11","guid":{"rendered":"http:\/\/fastbitlab.com\/?p=7199"},"modified":"2023-09-12T15:40:59","modified_gmt":"2023-09-12T10:10:59","slug":"building-a-linux-kernel-module","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/","title":{"rendered":"Linux Device Driver Programming Lecture 21- Building a linux kernel module"},"content":{"rendered":"
\n
\n
\n
\n

 <\/p>\n<\/div>\n

\n

Building a linux kernel module<\/b><\/span><\/h1>\n
\n
\n
\n

 <\/p>\n

<\/div>\n

 <\/p>\n<\/div>\n<\/div>\n<\/div>\n

In this article, let’s learn how to build a kernel module.<\/span><\/p>\n

Kernel modules can be built in two ways: statically linked against the kernel image or as dynamically loadable modules.<\/span><\/p>\n

We will be writing and using dynamically loadable kernel modules for most of the exercises. Let’s say you want to build a kernel module as a dynamically loadable kernel module.<\/span><\/span><\/p>\n

\"Dynamically
Figure 1. Dynamically loadable kernel modules<\/span><\/figcaption><\/figure>\n

 <\/p>\n

One is <\/span>In tree module<\/b>, and another one is an Out<\/strong><\/span> of tree module<\/b>.<\/span><\/span><\/p>\n

 <\/p>\n

What exactly is an In tree module?<\/b><\/span><\/p>\n

\n

In tree, modules means internal to the linux kernel tree.<\/span><\/p>\n<\/blockquote>\n

For example, in the earlier articles, you actually ran a command modules, make modules to build all dynamically loadable kernel modules of the Linux kernel. All those modules are called as In tree modules. That means, they are internal to the linux kernel tree.<\/span><\/p>\n

 <\/p>\n

What exactly is an out of tree module?<\/b><\/span><\/p>\n

\n

It is external to the linux kernel tree. The module that we just wrote, our hello world module, it is an Out of tree module. <\/span><\/p>\n<\/blockquote>\n

Loading Out of tree module taints the kernel. That is, kernel issues a warning saying Out of tree module has been loaded. This is just a warning from the kernel, and we can safely ignore this warning. You will see that when you load that module to the kernel.<\/span><\/p>\n

 <\/p>\n

Basically, out of tree means outside of the Linux kernel source tree. The modules which are already part of the Linux kernel are called In tree modules. That is approved by the kernel developers and maintainers. <\/span><\/p>\n

When you write a module separately (which is not approved and may be buggy), build and link it against the running kernel, then it’s called as out of the tree module. Hence when you load an out of tree kernel module, kernel throws a warning message saying it got tainted. That is, a taint flag will be set in the kernel. <\/span><\/p>\n

Let’s explore building a kernel module as Out of tree. Later will also explore In tree building.<\/span><\/p>\n

 <\/p>\n

Importance of the Kernel Build System (“kbuild”):<\/strong><\/span><\/p>\n

Modules are built using “kbuild” which is the build system used by the Linux kernel. Doesn’t matter whether it is a static module or dynamic module, modules are built using  “kbuild”, that is, the kernel build.<\/span><\/p>\n

Modules must use “kernel build system” to stay compatible with changes in the build infrastructure and to pick up the right flags to GCC.<\/span><\/p>\n

 <\/p>\n

When you compile a user-level program, what do you do? <\/strong><\/span><\/p>\n

You use a compiler called GCC, and you use various compiler flags, you use various linker flags to compile your program, So the same procedure we have to follow here, but while building a kernel module, you need not worry about what kind of compiler switches or compiler arguments you have to use the compiler. You have to invoke the kernel build system, and the kernel build system will take care of using the right compiler switches to the compiler. <\/span><\/p>\n

To build external modules, you must have a prebuilt kernel source available that contains the configuration and header files used in the build. Basically, we have already installed the kernel source. We will be building our module against that prebuilt kernel source.<\/span><\/p>\n

This ensures that as the developer changes the kernel configuration, his custom driver is automatically rebuilt with the current kernel configuration. If you need more information about building a module using  “kbuild,” you can go through the kernel documentation at this path.<\/span><\/p>\n

 <\/p>\n

There are some important note I would like to mention, so please remember that when you are building an Out of tree module, you need to have a complete and pre-compiled kernel source tree on your system. This we have already done. We have downloaded the kernel source tree and built it. The reason is modules are linked against object files found in the kernel source tree. <\/span><\/p>\n

You cannot compile your module against one Linux kernel version and load it into the system, which is running kernel of a different version. The module load may not be successful, and even if it is successful, you will encounter runtime issues with the symbols.  That’s why the thumb rule is “Have a precompiled  Linux kernel source tree on your machine and build your module against that”. <\/span><\/p>\n

There are two ways to obtain a prebuilt kernel version. Download the kernel from your distributor and build it by yourself. This is what we did, or install the Linux- headers-of the target Linux kernel.<\/span><\/p>\n

Let’s say you have an embedded system where the board is already running a Linux kernel of some different version. And now you have to write a driver for that board. What you do is, you try to get the kernel source of that running Linux kernel version.<\/span><\/p>\n

So, if you don’t get the full Linux source, then at least try to download the Linux headers of the target Linux kernel version. And build your module against that. As I said, you cannot compile your module against one Linux kernel version and load it into the system which is running a different kernel version. Don’t try to do that.<\/span><\/p>\n

That’s a reason why we downloaded the Linux kernel source from the beagle bone repository, compiled it, and updated the Linux kernel image in the target. <\/span><\/p>\n

Now, the version of the target Linux kernel and version of the source that we have got in our system is the same. We are just going to build our module against the source what we have installed.<\/span><\/p>\n

 <\/p>\n

Let’s see the procedure to build an Out of tree kernel module(Figure 2).<\/span><\/p>\n

\"Figure
Figure 2. Building a kernel module(out of tree)<\/span><\/figcaption><\/figure>\n

 <\/p>\n

And maybe in the next article, let’s explore building an In tree kernel module<\/a><\/span>. Above command you have to use. <\/span><\/span><\/p>\n

A very simple command, you just have to use make command, that’s it. Now the idea here is you have to trigger the top-level makefile of the Linux kernel source tree, that’s a key thing here. And to trigger top-level makefile of the Linux kernel source tree, we use <\/span>-C<\/b> switch with the make. <\/span><\/span><\/p>\n

When you execute make<\/strong><\/span> -C<\/b>, make first enters into the Linux kernel source tree, and it executes a top-level make file.<\/span><\/span><\/p>\n

That’s how kernel build system triggers. And when the make invokes top-level make file, all the compiler switches, the dependency lists, version string, everything will be utilized to build your kernel module. <\/span>When make invokes the top-level makefile, you then have to direct the top-level makefile to your local makefile or a local folder where you have kept your Out of tree module source.<\/span><\/span><\/p>\n

And we direct the top-level make file to our local folder by using the variable <\/span>M<\/b>. <\/span>M<\/b> is equal to you have to give path to your module source. And after that, this command also includes target options. <\/span><\/span><\/p>\n

First, you have to use <\/span>make -C<\/b>, path to the Linux kernel tree to invoke the top-level makefile of the kernel source tree, and when make invokes the top-level makefile of the Linux kernel tree, the kernel build system triggers, and you have to use the variable <\/span>M<\/b> to direct the build flow to enter into your local folder where you have kept your module source file. <\/span><\/span><\/p>\n

 <\/p>\n

This is a command syntax in short make -C kernel directory and M=path to the local module, and then you have to mention targets.<\/span><\/p>\n

\"Figure
Figure 3. Command syntax<\/span><\/figcaption><\/figure>\n

 <\/p>\n

We will explore the targets later. Now, for the targets, you can use these options, as shown in Figure 4.<\/span><\/p>\n

\"Building
Figure 4. Target options<\/span><\/figcaption><\/figure>\n

 <\/p>\n

If you want to build a module, then use command modules. If you want to install the module, then use a command modules install. If you want to clean up all the generated files in the module directory, then use clean. And if you want to get any help, then you just use help command here. These are the different targets.<\/span><\/p>\n

We have already used these targets. We have used modules, we have used modules_install, the same target option you can use with this command. <\/span><\/p>\n

 <\/p>\n

Let’s see creating a local makefile as shown in Figure 5. As I said, the top-level makefile will invoke the local makefile. This you need to create by yourself. In the local makefile, you should define a kbuild variable like below.<\/span><\/p>\n

\"Building
Figure 5. Creating local Makefile<\/span><\/figcaption><\/figure>\n

 <\/p>\n

You have to use a kbuild variable called <\/span>obj-<\/b> you can use three different values here <\/span>n,y, <\/b>or<\/span> m. <\/b>And after that, you have to mention the <\/span>module_name .o<\/b>. <\/span><\/span><\/p>\n

 <\/p>\n

Let’s understand how to create a local makefile.<\/span><\/p>\n

In the local makefile you should define a kbuild variable like <\/span>obj-<X> := <module_name>.o<\/b>. You have to use the kbuild variable obj- and you have to use the appropriate option. And then equate that to your <\/span>module_name .o<\/b>. Here, ‘<\/span>X<\/b>‘ takes one of the values. It could be <\/span>n<\/b>, or it could be <\/span>y<\/b>, or it could be <\/span>m<\/b>. If it is <\/span>n<\/b>, that means do not compile the module. When your kbuild system visits the local folder, it reads the local makefile, and it reads this variable <\/span>obj- <\/b>it could be <\/span>n,y, <\/b>or <\/span>m<\/b>. If it is <\/span>y<\/b>, that means compile the module and link with the kernel image. That means, it’s a static module if it is <\/span>y<\/b>. If ‘<\/span>X<\/b>‘ is m, then compile as a dynamically loadable kernel module.<\/span><\/span><\/p>\n

All you need to do is, you have to create a make file and write this statement <\/span>obj-m := main.o <\/b>(as in Figure 6).<\/span><\/span><\/p>\n

\"Building
Figure 6. Kbuild variable<\/span><\/figcaption><\/figure>\n

 <\/p>\n

Let’s say I have a kernel module source file <\/span>main. c<\/b> and I want to build it as a dynamically loadable kernel module, and then I would just mention <\/span>obj-m := main.o<\/b>. When the kernel build system sees this statement, the kbuild system will build main.o, that is, object file from <\/span>main.c<\/b>, and after linking, it will result in the kernel module, <\/span>main. ko<\/b>. <\/span><\/span><\/p>\n

Remember that you should not mention <\/span>main.c <\/b>here. <\/span>main.c<\/b> is a source, our target is <\/span>main.o<\/b> object file. That’s why you have to write <\/span>main.o<\/b>.<\/span><\/span><\/p>\n

So, the kernel build system creates the target that is <\/span>main.o<\/b>, and after linking, the kernel module <\/span>main.ko<\/b> will be generated. <\/span><\/span><\/p>\n

I hope you get the idea and let’s try all these things practically on our hello world kernel module, and I will see you in the next article<\/a><\/span>.<\/span><\/span><\/p>\n

 <\/p>\n

Get the Full Course on Linux Device Driver(LDD1) Here<\/a><\/span>.<\/span><\/strong><\/p>\n

FastBit Embedded Brain Academy Courses<\/b><\/span><\/p>\n

Click here: <\/span>https:\/\/fastbitlab.com\/course1<\/a><\/span><\/p>\n

 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

  Building a linux kernel module     In this article, let’s learn how to build a kernel module. Kernel modules can be built in two ways: statically linked against the kernel image or as dynamically loadable modules. We will be writing and using dynamically loadable kernel modules for most of the exercises. Let’s say […]<\/p>\n","protected":false},"author":1,"featured_media":7202,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"ocean_post_layout":"","ocean_both_sidebars_style":"","ocean_both_sidebars_content_width":0,"ocean_both_sidebars_sidebars_width":0,"ocean_sidebar":"0","ocean_second_sidebar":"0","ocean_disable_margins":"enable","ocean_add_body_class":"","ocean_shortcode_before_top_bar":"","ocean_shortcode_after_top_bar":"","ocean_shortcode_before_header":"","ocean_shortcode_after_header":"","ocean_has_shortcode":"","ocean_shortcode_after_title":"","ocean_shortcode_before_footer_widgets":"","ocean_shortcode_after_footer_widgets":"","ocean_shortcode_before_footer_bottom":"","ocean_shortcode_after_footer_bottom":"","ocean_display_top_bar":"default","ocean_display_header":"default","ocean_header_style":"","ocean_center_header_left_menu":"0","ocean_custom_header_template":"0","ocean_custom_logo":0,"ocean_custom_retina_logo":0,"ocean_custom_logo_max_width":0,"ocean_custom_logo_tablet_max_width":0,"ocean_custom_logo_mobile_max_width":0,"ocean_custom_logo_max_height":0,"ocean_custom_logo_tablet_max_height":0,"ocean_custom_logo_mobile_max_height":0,"ocean_header_custom_menu":"0","ocean_menu_typo_font_family":"0","ocean_menu_typo_font_subset":"","ocean_menu_typo_font_size":0,"ocean_menu_typo_font_size_tablet":0,"ocean_menu_typo_font_size_mobile":0,"ocean_menu_typo_font_size_unit":"px","ocean_menu_typo_font_weight":"","ocean_menu_typo_font_weight_tablet":"","ocean_menu_typo_font_weight_mobile":"","ocean_menu_typo_transform":"","ocean_menu_typo_transform_tablet":"","ocean_menu_typo_transform_mobile":"","ocean_menu_typo_line_height":0,"ocean_menu_typo_line_height_tablet":0,"ocean_menu_typo_line_height_mobile":0,"ocean_menu_typo_line_height_unit":"","ocean_menu_typo_spacing":0,"ocean_menu_typo_spacing_tablet":0,"ocean_menu_typo_spacing_mobile":0,"ocean_menu_typo_spacing_unit":"","ocean_menu_link_color":"","ocean_menu_link_color_hover":"","ocean_menu_link_color_active":"","ocean_menu_link_background":"","ocean_menu_link_hover_background":"","ocean_menu_link_active_background":"","ocean_menu_social_links_bg":"","ocean_menu_social_hover_links_bg":"","ocean_menu_social_links_color":"","ocean_menu_social_hover_links_color":"","ocean_disable_title":"default","ocean_disable_heading":"default","ocean_post_title":"","ocean_post_subheading":"","ocean_post_title_style":"","ocean_post_title_background_color":"","ocean_post_title_background":0,"ocean_post_title_bg_image_position":"","ocean_post_title_bg_image_attachment":"","ocean_post_title_bg_image_repeat":"","ocean_post_title_bg_image_size":"","ocean_post_title_height":0,"ocean_post_title_bg_overlay":0.5,"ocean_post_title_bg_overlay_color":"","ocean_disable_breadcrumbs":"default","ocean_breadcrumbs_color":"","ocean_breadcrumbs_separator_color":"","ocean_breadcrumbs_links_color":"","ocean_breadcrumbs_links_hover_color":"","ocean_display_footer_widgets":"default","ocean_display_footer_bottom":"default","ocean_custom_footer_template":"0","ocean_post_oembed":"","ocean_post_self_hosted_media":"","ocean_post_video_embed":"","ocean_link_format":"","ocean_link_format_target":"self","ocean_quote_format":"","ocean_quote_format_link":"post","ocean_gallery_link_images":"off","ocean_gallery_id":[],"footnotes":""},"categories":[8],"tags":[18],"class_list":["post-7199","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog","tag-linux-device-driver-programming","entry","has-media"],"yoast_head":"\nBuilding a Linux Kernel Module: Out-of-Tree Development Guide<\/title>\n<meta name=\"description\" content=\"Building a linux kernel module. Learn how to build Linux kernel modules as dynamically loadable out-of-tree modules. Importance of 'kbuild'\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Building a Linux Kernel Module: Out-of-Tree Development Guide\" \/>\n<meta property=\"og:description\" content=\"Building a linux kernel module. Learn how to build Linux kernel modules as dynamically loadable out-of-tree modules. Importance of 'kbuild'\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/\" \/>\n<meta property=\"og:site_name\" content=\"FastBit EBA\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/fastbiteba\/\" \/>\n<meta property=\"article:published_time\" content=\"2022-02-08T11:21:11+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-12T10:10:59+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/Figure-1-4.png\" \/>\n\t<meta property=\"og:image:width\" content=\"791\" \/>\n\t<meta property=\"og:image:height\" content=\"378\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"FastBitLab\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@fastbiteba\" \/>\n<meta name=\"twitter:site\" content=\"@fastbiteba\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"FastBitLab\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/\"},\"author\":{\"name\":\"FastBitLab\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\"},\"headline\":\"Linux Device Driver Programming Lecture 21- Building a linux kernel module\",\"datePublished\":\"2022-02-08T11:21:11+00:00\",\"dateModified\":\"2023-09-12T10:10:59+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/\"},\"wordCount\":1868,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/Figure-1-4.png\",\"keywords\":[\"Linux Device Driver Programming Tutorial\"],\"articleSection\":[\"Blog\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/\",\"name\":\"Building a Linux Kernel Module: Out-of-Tree Development Guide\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/Figure-1-4.png\",\"datePublished\":\"2022-02-08T11:21:11+00:00\",\"dateModified\":\"2023-09-12T10:10:59+00:00\",\"description\":\"Building a linux kernel module. Learn how to build Linux kernel modules as dynamically loadable out-of-tree modules. Importance of 'kbuild'\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/#primaryimage\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/Figure-1-4.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/Figure-1-4.png\",\"width\":791,\"height\":378,\"caption\":\"Figure 1. Dynamically loadable kernel modules\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/building-a-linux-kernel-module\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Linux Device Driver Programming Lecture 21- Building a linux kernel module\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\",\"name\":\"FastBit EBA\",\"description\":\"Your Online Academy of Embedded Systems\",\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\",\"name\":\"FastBit EBA\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/04\\\/logo-EzNrEnyr.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/04\\\/logo-EzNrEnyr.png\",\"width\":640,\"height\":640,\"caption\":\"FastBit EBA\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/fastbiteba\\\/\",\"https:\\\/\\\/x.com\\\/fastbiteba\",\"https:\\\/\\\/www.linkedin.com\\\/in\\\/fastbit-embedded-brain-academy-b3167b124\\\/\",\"https:\\\/\\\/www.youtube.com\\\/channel\\\/UCa1REBV9hyrzGp2mjJCagBg\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\",\"name\":\"FastBitLab\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"caption\":\"FastBitLab\"},\"description\":\"The FastBit Embedded Brain Academy uses the power of internet to bring the online courses related to the field of embedded system programming, Real time operating system, Embedded Linux systems, etc at your finger tip with very low cost. Backed with strong experience of industry, we have produced lots of courses with the customer enrolment over 3000+ across 100+ countries.\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Building a Linux Kernel Module: Out-of-Tree Development Guide","description":"Building a linux kernel module. Learn how to build Linux kernel modules as dynamically loadable out-of-tree modules. Importance of 'kbuild'","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/","og_locale":"en_US","og_type":"article","og_title":"Building a Linux Kernel Module: Out-of-Tree Development Guide","og_description":"Building a linux kernel module. Learn how to build Linux kernel modules as dynamically loadable out-of-tree modules. Importance of 'kbuild'","og_url":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/","og_site_name":"FastBit EBA","article_publisher":"https:\/\/www.facebook.com\/fastbiteba\/","article_published_time":"2022-02-08T11:21:11+00:00","article_modified_time":"2023-09-12T10:10:59+00:00","og_image":[{"width":791,"height":378,"url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/Figure-1-4.png","type":"image\/png"}],"author":"FastBitLab","twitter_card":"summary_large_image","twitter_creator":"@fastbiteba","twitter_site":"@fastbiteba","twitter_misc":{"Written by":"FastBitLab","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/#article","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/"},"author":{"name":"FastBitLab","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d"},"headline":"Linux Device Driver Programming Lecture 21- Building a linux kernel module","datePublished":"2022-02-08T11:21:11+00:00","dateModified":"2023-09-12T10:10:59+00:00","mainEntityOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/"},"wordCount":1868,"commentCount":0,"publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/Figure-1-4.png","keywords":["Linux Device Driver Programming Tutorial"],"articleSection":["Blog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/","url":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/","name":"Building a Linux Kernel Module: Out-of-Tree Development Guide","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/#primaryimage"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/Figure-1-4.png","datePublished":"2022-02-08T11:21:11+00:00","dateModified":"2023-09-12T10:10:59+00:00","description":"Building a linux kernel module. Learn how to build Linux kernel modules as dynamically loadable out-of-tree modules. Importance of 'kbuild'","breadcrumb":{"@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/#primaryimage","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/Figure-1-4.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/Figure-1-4.png","width":791,"height":378,"caption":"Figure 1. Dynamically loadable kernel modules"},{"@type":"BreadcrumbList","@id":"https:\/\/fastbitlab.com\/blog\/building-a-linux-kernel-module\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fastbitlab.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Linux Device Driver Programming Lecture 21- Building a linux kernel module"}]},{"@type":"WebSite","@id":"https:\/\/fastbitlab.com\/blog\/#website","url":"https:\/\/fastbitlab.com\/blog\/","name":"FastBit EBA","description":"Your Online Academy of Embedded Systems","publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/fastbitlab.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/fastbitlab.com\/blog\/#organization","name":"FastBit EBA","url":"https:\/\/fastbitlab.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2026\/04\/logo-EzNrEnyr.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2026\/04\/logo-EzNrEnyr.png","width":640,"height":640,"caption":"FastBit EBA"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/fastbiteba\/","https:\/\/x.com\/fastbiteba","https:\/\/www.linkedin.com\/in\/fastbit-embedded-brain-academy-b3167b124\/","https:\/\/www.youtube.com\/channel\/UCa1REBV9hyrzGp2mjJCagBg"]},{"@type":"Person","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d","name":"FastBitLab","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","caption":"FastBitLab"},"description":"The FastBit Embedded Brain Academy uses the power of internet to bring the online courses related to the field of embedded system programming, Real time operating system, Embedded Linux systems, etc at your finger tip with very low cost. Backed with strong experience of industry, we have produced lots of courses with the customer enrolment over 3000+ across 100+ countries."}]}},"_links":{"self":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/7199","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/comments?post=7199"}],"version-history":[{"count":4,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/7199\/revisions"}],"predecessor-version":[{"id":15906,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/7199\/revisions\/15906"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media\/7202"}],"wp:attachment":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media?parent=7199"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/categories?post=7199"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/tags?post=7199"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}