{"id":8130,"date":"2022-03-07T04:11:34","date_gmt":"2022-03-07T04:11:34","guid":{"rendered":"http:\/\/fastbitlab.com\/?p=8130"},"modified":"2023-09-16T11:17:11","modified_gmt":"2023-09-16T05:47:11","slug":"linux-device-driver-programming-lecture-47-error-handling","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/","title":{"rendered":"Linux Device Driver Programming Lecture 47- Error handling"},"content":{"rendered":"
\n
\n
\n
\n

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

\n

Error handling<\/b><\/span><\/h1>\n
\n
\n
\n

 <\/p>\n

<\/div>\n

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

In this article, let’s understand an error handling, especially in our module’s initialization function. <\/span><\/p>\n

In kernel module programming, so the kernel coding a standard or kernel coding document recommends using the goto statement of  C programming language to error handling as shown in Figure 1.<\/span><\/p>\n

\"Figure
Figure 1. Goto statement for error handling<\/span><\/figcaption><\/figure>\n

This is just a recommendation, you may use it, or you may not use it because some people they do not recommend using goto statements in any program. But with a linux kernel programming, it is allowed. You can use this. But, it is also recommended that you use it only for error handling.<\/span><\/p>\n

 <\/p>\n

How a goto statement is useful in error handling?<\/b><\/span><\/p>\n

Here is an example. In most of the kernels initialization function, the kernel initialization codes will execute whenever you insert a module. If there is something that goes wrong or if any kernel function returns an error code or null pointer or something like that, then you cannot insert the module. The module insertion fails.<\/span><\/p>\n

In that case, you should detect the errors, and you should undo some operations. That means you should a destroy some data structures, or you should free some memory.<\/span><\/p>\n

Let’s say, in the modules initialization function, you are trying something, let’s say try_something_1. If that is not an error, then you try_something_2. And if that is not an error, then you try_something_3. While trying something 3, if something goes wrong. That means, if  try_something_3 gives you an error, then you should go to the else part. <\/span><\/p>\n

And now you cannot insert your module. There is a problem in try_something_3. You should undo the successful executions of try_something_1 and try_something_2. Because they might have a utilized some data structures of the kernel, or they may be holding some kernels memory, something like that. You should undo that.<\/span><\/p>\n

Such scenarios are very much common in kernel module programming or device driver programming. That means you try something, and if something goes wrong, then you undo the previous successful operations, and you exit.<\/span><\/p>\n

 <\/p>\n

For that purpose, you can, of course, use nested if and else statement, something which is shown here as shown in Figure 2.<\/span><\/p>\n

\"Figure
Figure 2. Goto statement for error handling using if and else statement<\/span><\/figcaption><\/figure>\n

 <\/p>\n

This looks bit complicated, and the code doesn’t look good. The same thing you can implement by using a combination of if and goto statements, something which <\/span>is shown in Figure 3.<\/span><\/span><\/p>\n

\"Figure
Figure 3. Goto statement for error handling using if and goto statement<\/span><\/figcaption><\/figure>\n

You can see that this code looks very much clean than this one. Here what you do is you try_something_1, if there is no error,  then you try_something_2. And if  try_something_2 is equal to error, then you don’t go to try_something_3. So, you branch out from there. <\/span><\/p>\n

You take the help of goto statement to exit that code block, and you goto the error handling code block of error two. There you do the undoing operation of the previous one. That is undo of try_something_1. And then you return. This looks clean, and this looks simple. And it is very much straightforward.<\/span><\/p>\n

In our driver’s module initialization function, we need to introduce this error handling now, and we’ll be using a combination of if and goto statements.<\/span><\/p>\n

 <\/p>\n

Let’s see how to implement error handling in the module initialization function practically. Let me open pcd.c, and let’s goto our module init.<\/span><\/p>\n

static int<\/span> __init pcd_driver_init(void)\r\n{\r\n     int<\/span> ret;\r\n\r\n    \/*1. Dynamically allocate a device number *\/<\/span>\r\n    ret = alloc_chrdev_region(&device_number,0,1,\"pcd_devices\");\r\n    if<\/span>(ret < 0){\r\n            goto out<\/span>;\r\n    pr_info(\"Device number <major>:<minor> = %d:%d\\n\",MAJOR(device_number),MINOR(device_number));\r\n\r\n    \/*2. Initialize the cdev structure with fops*\/<\/span>\r\n    cdev_init(&pcd_cdev,&pcd_fops);\r\n\r\n    \/* 3. Register a device (cdev structure) with VFS *\/<\/span>\r\n    pcd_cdev.owner = THIS_MODULE;\r\n    cdev_add(&pcd_cdev,device_number,1);\r\n\r\n    \/*4. create device class under \/sys\/class\/ *\/<\/span>\r\n    class_pcd = class_create(THIS_MODULE,\"pcd_class\");\r\n\r\n   \/*5. populate the sysfs with device information *\/<\/span>\r\n   device_pcd = device_create(class_pcd,NULL,device_number,NULL,\"pcd\");\r\n\r\n\r\n   pr_info(\"Module init was successful\\n\");\r\n\r\n    return<\/span> 0;\r\nout:<\/span>\r\n    return<\/span> ret;\r\n}<\/pre>\n
Implement error handling in module initialization<\/span><\/p>\n
First of all, alloc_chrdev_region. This is a kernel function, which may fail  remember that. alloc_chrdev_region return 0 or it returns a negative error code.<\/span><\/p>\n
If it returns a negative error code, then you cannot insert your module. Because you couldn’t allocate the device number, so you cannot proceed. Let’s take care of this condition. <\/span><\/p>\n
Let me create a variable called error or ret, return value. Just ret. So, let’s catch what alloc_chrdev_region returns. If a return is less than 0, then let’s use goto statement. Let me use a tag name out. This is a tag out. <\/span><\/p>\n
Now, let me implement that out<\/strong> code block, as shown above.<\/span><\/p>\n
It branches out here to this label out, so the control comes all the way to this label out, and here it returns the error code.<\/span><\/p>\n
\"Figure
Figure 4. Skipped code<\/span><\/figcaption><\/figure>\n
All these code blocks will be skipped (shown in Figure 4). That’s what we wanted.<\/span><\/p>\n
 <\/p>\n
Let’s go for cdev_init. First, let’s check cdev_init. <\/span><\/p>\n
what it returns? <\/span><\/p>\n
cdev_init it is void. It doesn’t return anything, as shown in Figure 5, so need not to check that. <\/span><\/p>\n
\"Figure
Figure 5. Char_dev.c file<\/span><\/figcaption><\/figure>\n
 <\/p>\n
Let’s proceed to cdev_add. cdev_add it also returns a negative error code on failure, as shown in Figure 6.<\/span><\/p>\n
\"Figure
Figure 6. C_dev add file<\/span><\/figcaption><\/figure>\n
 <\/p>\n
We have to check that. So, ret is equal to. Let’s catch that error value if (ret<0), goto let’s give one label. I would call this label as unreg_chrdev, as shown in Figure 7.<\/span><\/p>\n
     \/* 3. Register a device (cdev structure) with VFS *\/<\/span>\r\n    pcd_cdev.owner = THIS_MODULE;\r\n    ret = cdev_add(&pcd_cdev,device_number,1);\r\n    if<\/span>(ret < 0){\r\n                 goto<\/span> unreg_chrdev;<\/pre>\n
Figure 7. Error handling in c_dev add<\/span><\/p>\n
   \/*5. populate the sysfs with device information *\/<\/span>\r\n   device_pcd = device_create(class_pcd,NULL,device_number,NULL,\"pcd\");\r\n\r\n   pr_info(\"Module init was successful\\n\");\r\n   return<\/span> 0;\r\n\r\nunreg_chrdev:<\/span>\r\n       unregister_chrdev_region(device_number,1);\r\nout:<\/span>\r\n       return<\/span> ret;\r\n}<\/pre>\n
Figure 8. unreg_chrdev<\/span><\/p>\n
This label you have to implement before this out, as shown in Figure 8. This is out, this is a last one.<\/span><\/p>\n
You have to write that label ‘unreg_chrdev’. Here, you should undo the previous operation, that is, this (alloc_chrdev_region) operation. <\/span><\/p>\n
What is undoing of this(alloc_chrdev_region) one? <\/span><\/p>\n
You have to use unregister_chrdev_region. <\/span><\/p>\n
Let’s see what happens here(in Figure 7).  When ret is less than 0, goto unreg_chrdev. It comes to unreg_chrdev. It unregisters the device number here, and it returns.<\/span><\/p>\n
 <\/p>\n
Now, let’s check this one class_create. <\/span><\/p>\n
What class_create does? <\/span><\/p>\n
Let’s check that. Here it is class_create, as shown in Figure 9.<\/span><\/p>\n
\"Figure
Figure 9. Class create function<\/span><\/figcaption><\/figure>\n
class_create returns a pointer. It returns address of struct class pointer on success. If there is any failure, then it returns error code. So, while doing  kernel programming, you should be careful with those kernel  function, which return pointer to some structure. <\/span><\/p>\n
For example, in this case, class_create is returning a pointer to struct class. If class_create is successful, then a valid pointer is returned.<\/span><\/p>\n
If class_create is not successful, then null is not return. You may be having a habit of checking for null. But, in this case, you cannot check for null. Null is not returned. If there is any failure in class _create, pointer to error code is return.<\/span><\/p>\n
\"Figure
Figure 10. Retval type<\/span><\/figcaption><\/figure>\n
You can see what it returns here(shown in Figure 10). <\/span><\/p>\n
What  is retval here?<\/span><\/p>\n
 Return val was a integer. This integer is converted into a pointer using this macro ERR_PTR. Error code is converted as a pointer. This function should return a pointer. That’s why it cannot simply return this retval. Because that is int. So, that’s why this int is converted into a pointer type.<\/span><\/p>\n
 <\/p>\n
This ERR_PTR is there in err.h, as show in Figure 11.<\/span><\/p>\n
\"Figure
Figure 11. ERR_PTR code<\/span><\/figcaption><\/figure>\n
This is ERR_PTR. It just converts this value into a pointer. <\/span><\/p>\n
How do you handle such things in your code?<\/span><\/p>\n
 <\/p>\n
\"Figure
Figure 12. Error code implementation in device create<\/span><\/figcaption><\/figure>\n
Here, what you should do is, if there is a successful invocation of class_create, a valid pointer is returned. But, if this function fails, then null is not returned remember, it returns a pointer to an error code. That’s why we should check this pointer. <\/span><\/p>\n
To understand whether it is a valid pointer or whether it is a pointer to an error code. That’s a reason why we should use a macro called IS_ERR.<\/span><\/p>\n
Just pass that pointer class_pcd. If IS_ERR is true, that means class_create has failed. And this pointer variable holds pointer to an error code. Here, you can print pr_info pr_err. <\/span><\/p>\n
What’s a error code? <\/span><\/p>\n
So, now we can extract the error code by using a macro  pointer to error, PTR_ERR. Just pass this pointer class_pcd. And then you should goto undoing of all things. I would call this as goto a cdev_del.<\/span><\/p>\n
Because if this is failure, then you should undo this cdev_add.  That’s why I would give a label cdev_del. class_pcd is a pointer. This pointer(class_pcd) I cannot equate to ret. This class_pcd is a pointer, ret is a int value.<\/span><\/p>\n
I cannot equate that. What I did was, I converted pointer to error code. So, that’s why we have to use PTR_ERR macro, which is there in err.h.<\/span><\/p>\n
So, here it is Error handling of pointers during kernel function return as shown in Figure 13.<\/span><\/p>\n
\"Figure
Figure 13. Error handling of pointers during kernel function return<\/span><\/figcaption><\/figure>\n
Whenever you are using any kernel function, and then you should go to the source code of that, and  you should check the return value.  That is no trick to understand what exactly a kernel function returns, you have to check the source code.<\/span><\/p>\n
If the kernel function is returning a pointer, then most probably you should be using these macros in order to handle that a return pointer. These macro’s you can use to deal with a return of error pointers by kernel functions. <\/span><\/p>\n
The below macros help to understand what made kernel function to fail. <\/span>If any kernel function fails, and if it returns null, then you don’t have any idea why did it fail. That’s why most of the kernel functions they don’t return null rather, they return pointer to a error code. <\/span><\/span><\/p>\n
That’s why, most probably, we will be dealing with these three macros IS_ERR(), which will test whether that pointer what is return by the  kernel function is a valid pointer or whether it is a pointer to an error code. And PTR_ERR() converts pointer to error code. That is pointer value to int value. And ERR_PTR converts error to pointer. That means, int  value to pointer value.<\/span><\/p>\n
 <\/p>\n
Let’s go back to our code, as shown in Figure 14.<\/span><\/p>\n
    \/*4. create device class under \/sys\/class\/ *\/<\/span>\r\n   class_pcd = class_create(THIS_MODULE,\"pcd_class\");\r\n   if<\/span>(IS_ERR(class_pcd)){\r\n       pr_err(\"Class creation failed\\n\");\r\n       ret = PTR_ERR(class_pcd);\r\n       goto<\/span> cdev_del;\r\n    }<\/pre>\n
Figure 14. Error handling<\/span><\/p>\n
Here, we are detecting whether the class_create was successful or not. If IS_ERR is true, then class_create was  failure. That’s why, we print class creation failed, and we convert the pointer to error code, and we store that here in the ret variable, and we exit from here. Go to cdev_del.<\/span><\/p>\n
 <\/p>\n
Let’s implement goto cdev_del here, as shown in Figure 15. cdev_del this is a label where you should do cdev_del.<\/span><\/p>\n
cdev_del<\/span>:\r\n     cdev_del(&pcd_cdev); \r\nunreg_chrdev<\/span>:\r\n     unregister_chrdev_region(device_number,1);\r\nout<\/span>:\r\n     return ret<\/span>;\r\n}<\/pre>\n
Figure 15. Cdev_del code<\/span><\/p>\n
This you must be doing here, as shown in Figure 15. It first does cdev_del <\/span>and after that unregister_chrdev_region  and then return. <\/span><\/span><\/p>\n
 <\/p>\n
Let’s check device_create, as shown in Figure 16.<\/span><\/p>\n
\"Figure
Figure 16. Device create structure<\/span><\/figcaption><\/figure>\n
Again, you can see that it returns struct device pointer on success or ERR_PTR() on error. So, we have to again handle this. The same way as you handle for class_creates.<\/span><\/p>\n
Now, let’s handle this return value if IS_ERR. Let’s check that pointer. device_pcd. <\/span>If this is error, then I would say  pr_err. “Device create failed”. PTR_ERR of <\/span>Device_pcd. Goto class_destroy. <\/span><\/span><\/p>\n
What is that? <\/span><\/span><\/p>\n
You should do class_destroy. <\/span>I would say class delete, something like that. Any label you can give. Let’s implement sorry, this is class_del. Class Delete.<\/span><\/span><\/p>\n
\"Figure
Figure 17. Error implementation in device create<\/span><\/figcaption><\/figure>\n
Let’s implement that class_del here. And let’s call  class_destroy. If device_create fails, then the class will be destroyed, cdev will be deleted,  unregister_chrdev_ region, and then return. This is how you should handle  the various error scenarios in your driver_init function. Let’s save this and exit.<\/span><\/p>\n
 <\/p>\n
\"Figure
Figure 18. Code class_del<\/span><\/figcaption><\/figure>\n
And let’s compile this, there is a problem at 172. Here, I should give a semicolon.<\/span><\/p>\n
We can also add some error messages here. Let me add one more error message here “chardev failed”. So, you can also add one more error message here. <\/span>And you can also add one more error message here. “Module insertion failed”. Let’s save and exit. <\/span><\/span><\/p>\n
 <\/p>\n
\"Figure
Figure 19. Print messages<\/span><\/figcaption><\/figure>\n
 <\/p>\n
Now, let’s do make the host, and the build is successful. That’s it for this article, and I will see you in the next article<\/span>.<\/a><\/span><\/p>\n
 <\/p>\n
FastBit Embedded Brain Academy Courses<\/b><\/span><\/p>\n
Click here:<\/span> <\/span><\/span>https:\/\/fastbitlab.com\/course1<\/span><\/a><\/span><\/p>\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
  Error handling     In this article, let’s understand an error handling, especially in our module’s initialization function. In kernel module programming, so the kernel coding a standard or kernel coding document recommends using the goto statement of  C programming language to error handling as shown in Figure 1. This is just a recommendation, […]<\/p>\n","protected":false},"author":1,"featured_media":8133,"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-8130","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog","tag-linux-device-driver-programming","entry","has-media"],"yoast_head":"\nError handling - Linux Device Driver Programming<\/title>\n<meta name=\"description\" content=\"Error handling.Learn how to implement robust error handling in kernel module initialization using the goto statement and if-else statements.\" \/>\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\/linux-device-driver-programming-lecture-47-error-handling\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Error handling - Linux Device Driver Programming\" \/>\n<meta property=\"og:description\" content=\"Error handling.Learn how to implement robust error handling in kernel module initialization using the goto statement and if-else statements.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/\" \/>\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-03-07T04:11:34+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-16T05:47:11+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/03\/Figure-1-13.png\" \/>\n\t<meta property=\"og:image:width\" content=\"680\" \/>\n\t<meta property=\"og:image:height\" content=\"321\" \/>\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=\"12 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/\"},\"author\":{\"name\":\"FastBitLab\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\"},\"headline\":\"Linux Device Driver Programming Lecture 47- Error handling\",\"datePublished\":\"2022-03-07T04:11:34+00:00\",\"dateModified\":\"2023-09-16T05:47:11+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/\"},\"wordCount\":2263,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/03\\\/Figure-1-13.png\",\"keywords\":[\"Linux Device Driver Programming Tutorial\"],\"articleSection\":[\"Blog\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/\",\"name\":\"Error handling - Linux Device Driver Programming\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/03\\\/Figure-1-13.png\",\"datePublished\":\"2022-03-07T04:11:34+00:00\",\"dateModified\":\"2023-09-16T05:47:11+00:00\",\"description\":\"Error handling.Learn how to implement robust error handling in kernel module initialization using the goto statement and if-else statements.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/#primaryimage\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/03\\\/Figure-1-13.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/03\\\/Figure-1-13.png\",\"width\":680,\"height\":321,\"caption\":\"Figure 1. Goto statement for error handling\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/linux-device-driver-programming-lecture-47-error-handling\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Linux Device Driver Programming Lecture 47- Error handling\"}]},{\"@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":"Error handling - Linux Device Driver Programming","description":"Error handling.Learn how to implement robust error handling in kernel module initialization using the goto statement and if-else statements.","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\/linux-device-driver-programming-lecture-47-error-handling\/","og_locale":"en_US","og_type":"article","og_title":"Error handling - Linux Device Driver Programming","og_description":"Error handling.Learn how to implement robust error handling in kernel module initialization using the goto statement and if-else statements.","og_url":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/","og_site_name":"FastBit EBA","article_publisher":"https:\/\/www.facebook.com\/fastbiteba\/","article_published_time":"2022-03-07T04:11:34+00:00","article_modified_time":"2023-09-16T05:47:11+00:00","og_image":[{"width":680,"height":321,"url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/03\/Figure-1-13.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":"12 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/#article","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/"},"author":{"name":"FastBitLab","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d"},"headline":"Linux Device Driver Programming Lecture 47- Error handling","datePublished":"2022-03-07T04:11:34+00:00","dateModified":"2023-09-16T05:47:11+00:00","mainEntityOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/"},"wordCount":2263,"commentCount":0,"publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/03\/Figure-1-13.png","keywords":["Linux Device Driver Programming Tutorial"],"articleSection":["Blog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/","url":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/","name":"Error handling - Linux Device Driver Programming","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/#primaryimage"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/03\/Figure-1-13.png","datePublished":"2022-03-07T04:11:34+00:00","dateModified":"2023-09-16T05:47:11+00:00","description":"Error handling.Learn how to implement robust error handling in kernel module initialization using the goto statement and if-else statements.","breadcrumb":{"@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/#primaryimage","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/03\/Figure-1-13.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/03\/Figure-1-13.png","width":680,"height":321,"caption":"Figure 1. Goto statement for error handling"},{"@type":"BreadcrumbList","@id":"https:\/\/fastbitlab.com\/blog\/linux-device-driver-programming-lecture-47-error-handling\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fastbitlab.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Linux Device Driver Programming Lecture 47- Error handling"}]},{"@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\/8130","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=8130"}],"version-history":[{"count":5,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/8130\/revisions"}],"predecessor-version":[{"id":15434,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/8130\/revisions\/15434"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media\/8133"}],"wp:attachment":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media?parent=8130"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/categories?post=8130"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/tags?post=8130"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}