Enforce Linux kernel coding style (#88)

The only exception is to indent with four spaces rather than tabs
for sticking to compact layout of source listing.

Close #87

examples/.clang-format

@@ -1,15 +1,94 @@
-BasedOnStyle: Chromium
 Language: Cpp
-MaxEmptyLinesToKeep: 3
-IndentCaseLabels: false
-AllowShortIfStatementsOnASingleLine: false
+
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignOperands: true
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
+
+BraceWrapping:
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: false
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeComma
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit: 80
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: false
 DerivePointerAlignment: false
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: false
+
+IncludeBlocks: Preserve
+IncludeCategories:
+  - Regex: '.*'
+    Priority: 1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentPPDirectives: None
+IndentWidth: 4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+
 PointerAlignment: Right
-SpaceAfterCStyleCast: true
+ReflowComments: false
+SortIncludes: false
+SortUsingDeclarations: false
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Cpp03
 TabWidth: 4
-UseTab: Never
-IndentWidth: 4
-BreakBeforeBraces: Linux
-AccessModifierOffset: -4
+UseTab: Never

examples/Makefile

@@ -36,3 +36,6 @@ all:
 clean:
 	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
 	$(RM) other/cat_noblock *.plist
+
+indent:
+	clang-format -i *[.ch]

examples/bottomhalf.c

@@ -21,19 +21,19 @@
 #define DECLARE_TASKLET_OLD(arg1, arg2) DECLARE_TASKLET(arg1, arg2, 0L)
 #endif
 
-static int button_irqs[] = {-1, -1};
+static int button_irqs[] = { -1, -1 };
 
 /* Define GPIOs for LEDs.
  * TODO: Change the numbers for the GPIO on your board.
  */
-static struct gpio leds[] = {{4, GPIOF_OUT_INIT_LOW, "LED 1"}};
+static struct gpio leds[] = { { 4, GPIOF_OUT_INIT_LOW, "LED 1" } };
 
 /* Define GPIOs for BUTTONS
  * TODO: Change the numbers for the GPIO on your board.
  */
 static struct gpio buttons[] = {
-    {17, GPIOF_IN, "LED 1 ON BUTTON"},
-    {18, GPIOF_IN, "LED 1 OFF BUTTON"},
+    { 17, GPIOF_IN, "LED 1 ON BUTTON" },
+    { 18, GPIOF_IN, "LED 1 OFF BUTTON" },
 };
 
 /* Tasklet containing some non-trivial amount of processing */
@@ -106,7 +106,6 @@ static int __init bottomhalf_init(void)
         goto fail2;
     }
 
-
     ret = gpio_to_irq(buttons[1].gpio);
 
     if (ret < 0) {

examples/chardev.c

@@ -21,14 +21,14 @@ static ssize_t device_write(struct file *, const char *, size_t, loff_t *);
 
 #define SUCCESS 0
 #define DEVICE_NAME "chardev" /* Dev name as it appears in /proc/devices   */
-#define BUF_LEN 80            /* Max length of the message from the device */
+#define BUF_LEN 80 /* Max length of the message from the device */
 
 /* Global variables are declared as static, so are global within the file. */
 
-static int major;               /* major number assigned to our device driver */
+static int major; /* major number assigned to our device driver */
 static int open_device_cnt = 0; /* Is device open?
                                  * Used to prevent multiple access to device */
-static char msg[BUF_LEN];       /* The msg the device will give when asked */
+static char msg[BUF_LEN]; /* The msg the device will give when asked */
 static char *msg_ptr;
 
 static struct class *cls;
@@ -105,8 +105,8 @@ static int device_release(struct inode *inode, struct file *file)
  * read from it.
  */
 static ssize_t device_read(struct file *filp, /* see include/linux/fs.h   */
-                           char *buffer,      /* buffer to fill with data */
-                           size_t length,     /* length of the buffer     */
+                           char *buffer, /* buffer to fill with data */
+                           size_t length, /* length of the buffer     */
                            loff_t *offset)
 {
     /* Number of bytes actually written to the buffer */
@@ -134,9 +134,7 @@ static ssize_t device_read(struct file *filp, /* see include/linux/fs.h   */
 }
 
 /* Called when a process writes to dev file: echo "hi" > /dev/hello */
-static ssize_t device_write(struct file *filp,
-                            const char *buff,
-                            size_t len,
+static ssize_t device_write(struct file *filp, const char *buff, size_t len,
                             loff_t *off)
 {
     pr_alert("Sorry, this operation is not supported.\n");

examples/chardev.h

@@ -40,7 +40,7 @@
 /* Get the n'th byte of the message */
 #define IOCTL_GET_NTH_BYTE _IOWR(MAJOR_NUM, 2, int)
 /* The IOCTL is used for both input and output. It receives from the user
- * a number, n, and returns Message[n].
+ * a number, n, and returns message[n].
  */
 
 /* The name of the device file */

examples/chardev2.c

@@ -20,15 +20,15 @@
 /* Is the device open right now? Used to prevent concurrent access into
  * the same device
  */
-static int Device_Open = 0;
+static int open_device_cnt = 0;
 
 /* The message the device will give when asked */
-static char Message[BUF_LEN];
+static char message[BUF_LEN];
 
 /* How far did the process reading the message get? Useful if the message
  * is larger than the size of the buffer we get to fill in device_read.
  */
-static char *Message_Ptr;
+static char *message_ptr;
 
 static struct class *cls;
 
@@ -38,12 +38,12 @@ static int device_open(struct inode *inode, struct file *file)
     pr_info("device_open(%p)\n", file);
 
     /* We don't want to talk to two processes at the same time. */
-    if (Device_Open)
+    if (open_device_cnt)
         return -EBUSY;
 
-    Device_Open++;
+    open_device_cnt++;
     /* Initialize the message */
-    Message_Ptr = Message;
+    message_ptr = message;
     try_module_get(THIS_MODULE);
     return SUCCESS;
 }
@@ -53,7 +53,7 @@ static int device_release(struct inode *inode, struct file *file)
     pr_info("device_release(%p,%p)\n", inode, file);
 
     /* We're now ready for our next caller */
-    Device_Open--;
+    open_device_cnt--;
 
     module_put(THIS_MODULE);
     return SUCCESS;
@@ -62,9 +62,9 @@ static int device_release(struct inode *inode, struct file *file)
 /* This function is called whenever a process which has already opened the
  * device file attempts to read from it.
  */
-static ssize_t device_read(struct file *file,   /* see include/linux/fs.h   */
+static ssize_t device_read(struct file *file, /* see include/linux/fs.h   */
                            char __user *buffer, /* buffer to be filled  */
-                           size_t length,       /* length of the buffer     */
+                           size_t length, /* length of the buffer     */
                            loff_t *offset)
 {
     /* Number of bytes actually written to the buffer */
@@ -73,17 +73,17 @@ static ssize_t device_read(struct file *file,   /* see include/linux/fs.h   */
     pr_info("device_read(%p,%p,%ld)\n", file, buffer, length);
 
     /* If at the end of message, return 0 (which signifies end of file). */
-    if (*Message_Ptr == 0)
+    if (*message_ptr == 0)
         return 0;
 
     /* Actually put the data into the buffer */
-    while (length && *Message_Ptr) {
+    while (length && *message_ptr) {
         /* Because the buffer is in the user data segment, not the kernel
          * data segment, assignment would not work. Instead, we have to
          * use put_user which copies data from the kernel data segment to
          * the user data segment.
          */
-        put_user(*(Message_Ptr++), buffer++);
+        put_user(*(message_ptr++), buffer++);
         length--;
         bytes_read++;
     }
@@ -97,19 +97,17 @@ static ssize_t device_read(struct file *file,   /* see include/linux/fs.h   */
 }
 
 /* called when somebody tries to write into our device file. */
-static ssize_t device_write(struct file *file,
-                            const char __user *buffer,
-                            size_t length,
-                            loff_t *offset)
+static ssize_t device_write(struct file *file, const char __user *buffer,
+                            size_t length, loff_t *offset)
 {
     int i;
 
     pr_info("device_write(%p,%s,%ld)", file, buffer, length);
 
     for (i = 0; i < length && i < BUF_LEN; i++)
-        get_user(Message[i], buffer + i);
+        get_user(message[i], buffer + i);
 
-    Message_Ptr = Message;
+    message_ptr = message;
 
     /* Again, return the number of input characters used. */
     return i;
@@ -123,7 +121,7 @@ static ssize_t device_write(struct file *file,
  * If the ioctl is write or read/write (meaning output is returned to the
  * calling process), the ioctl call returns the output of this function.
  */
-long device_ioctl(struct file *file,      /* ditto */
+long device_ioctl(struct file *file, /* ditto */
                   unsigned int ioctl_num, /* number and param for ioctl */
                   unsigned long ioctl_param)
 {
@@ -138,33 +136,33 @@ long device_ioctl(struct file *file,      /* ditto */
          * be the device's message.  Get the parameter given to ioctl by
          * the process.
          */
-        temp = (char *) ioctl_param;
+        temp = (char *)ioctl_param;
 
         /* Find the length of the message */
         get_user(ch, temp);
         for (i = 0; ch && i < BUF_LEN; i++, temp++)
             get_user(ch, temp);
 
-        device_write(file, (char *) ioctl_param, i, 0);
+        device_write(file, (char *)ioctl_param, i, 0);
         break;
 
     case IOCTL_GET_MSG:
         /* Give the current message to the calling process - the parameter
          * we got is a pointer, fill it.
          */
-        i = device_read(file, (char *) ioctl_param, 99, 0);
+        i = device_read(file, (char *)ioctl_param, 99, 0);
 
         /* Put a zero at the end of the buffer, so it will be properly
          * terminated.
          */
-        put_user('\0', (char *) ioctl_param + i);
+        put_user('\0', (char *)ioctl_param + i);
         break;
 
     case IOCTL_GET_NTH_BYTE:
         /* This ioctl is both input (ioctl_param) and output (the return
          * value of this function).
          */
-        return Message[ioctl_param];
+        return message[ioctl_param];
         break;
     }
 
@@ -178,7 +176,7 @@ long device_ioctl(struct file *file,      /* ditto */
  * is kept in the devices table, it can't be local to init_module. NULL is
  * for unimplemented functions.
  */
-struct file_operations Fops = {
+struct file_operations fops = {
     .read = device_read,
     .write = device_write,
     .unlocked_ioctl = device_ioctl,
@@ -190,7 +188,7 @@ struct file_operations Fops = {
 static int __init chardev2_init(void)
 {
     /* Register the character device (atleast try) */
-    int ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &Fops);
+    int ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &fops);
 
     /* Negative values signify an error */
     if (ret_val < 0) {

examples/cryptosha256.c

@@ -13,7 +13,7 @@ static void show_hash_result(char *plaintext, char *hash_sha256)
 
     pr_info("sha256 test for string: \"%s\"\n", plaintext);
     for (i = 0; i < SHA256_LENGTH; i++)
-        sprintf(&str[i * 2], "%02x", (unsigned char) hash_sha256[i]);
+        sprintf(&str[i * 2], "%02x", (unsigned char)hash_sha256[i]);
     str[i * 2] = 0;
     pr_info("%s\n", str);
 }
@@ -53,7 +53,9 @@ int cryptosha256_init(void)
     return 0;
 }
 
-void cryptosha256_exit(void) {}
+void cryptosha256_exit(void)
+{
+}
 
 module_init(cryptosha256_init);
 module_exit(cryptosha256_exit);

examples/cryptosk.c

@@ -93,8 +93,7 @@ static void test_skcipher_callback(struct crypto_async_request *req, int error)
 #endif
 }
 
-static int test_skcipher_encrypt(char *plaintext,
-                                 char *password,
+static int test_skcipher_encrypt(char *plaintext, char *password,
                                  struct skcipher_def *sk)
 {
     int ret = -EFAULT;
@@ -121,10 +120,10 @@ static int test_skcipher_encrypt(char *plaintext,
                                   test_skcipher_callback, &sk->result);
 
     /* clear the key */
-    memset((void *) key, '\0', SYMMETRIC_KEY_LENGTH);
+    memset((void *)key, '\0', SYMMETRIC_KEY_LENGTH);
 
     /* Use the world's favourite password */
-    sprintf((char *) key, "%s", password);
+    sprintf((char *)key, "%s", password);
 
     /* AES 256 with given symmetric key */
     if (crypto_skcipher_setkey(sk->tfm, key, SYMMETRIC_KEY_LENGTH)) {
@@ -153,7 +152,7 @@ static int test_skcipher_encrypt(char *plaintext,
             goto out;
         }
     }
-    sprintf((char *) sk->scratchpad, "%s", plaintext);
+    sprintf((char *)sk->scratchpad, "%s", plaintext);
 
     sg_init_one(&sk->sg, sk->scratchpad, CIPHER_BLOCK_SIZE);
     skcipher_request_set_crypt(sk->req, &sk->sg, &sk->sg, CIPHER_BLOCK_SIZE,

examples/devicemodel.c

@@ -13,7 +13,7 @@ struct devicemodel_data {
 static int devicemodel_probe(struct platform_device *dev)
 {
     struct devicemodel_data *pd =
-        (struct devicemodel_data *) (dev->dev.platform_data);
+        (struct devicemodel_data *)(dev->dev.platform_data);
 
     pr_info("devicemodel probe\n");
     pr_info("devicemodel greeting: %s; %d\n", pd->greeting, pd->number);

examples/example_atomic.c

@@ -6,10 +6,10 @@
 #include <linux/module.h>
 
 #define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
-#define BYTE_TO_BINARY(byte)                                  \
-    (byte & 0x80 ? '1' : '0'), (byte & 0x40 ? '1' : '0'),     \
-        (byte & 0x20 ? '1' : '0'), (byte & 0x10 ? '1' : '0'), \
-        (byte & 0x08 ? '1' : '0'), (byte & 0x04 ? '1' : '0'), \
+#define BYTE_TO_BINARY(byte)                                                   \
+    (byte & 0x80 ? '1' : '0'), (byte & 0x40 ? '1' : '0'),                      \
+        (byte & 0x20 ? '1' : '0'), (byte & 0x10 ? '1' : '0'),                  \
+        (byte & 0x08 ? '1' : '0'), (byte & 0x04 ? '1' : '0'),                  \
         (byte & 0x02 ? '1' : '0'), (byte & 0x01 ? '1' : '0')
 
 static void atomic_add_subtract(void)

examples/hello-2.c

@@ -2,7 +2,7 @@
  * hello-2.c - Demonstrating the module_init() and module_exit() macros.
  * This is preferred over using init_module() and cleanup_module().
  */
-#include <linux/init.h>   /* Needed for the macros */
+#include <linux/init.h> /* Needed for the macros */
 #include <linux/kernel.h> /* Needed for pr_info() */
 #include <linux/module.h> /* Needed by all modules */
 

examples/hello-3.c

@@ -1,7 +1,7 @@
 /*
  * hello-3.c - Illustrating the __init, __initdata and __exit macros.
  */
-#include <linux/init.h>   /* Needed for the macros */
+#include <linux/init.h> /* Needed for the macros */
 #include <linux/kernel.h> /* Needed for pr_info() */
 #include <linux/module.h> /* Needed by all modules */
 

examples/hello-4.c

@@ -1,7 +1,7 @@
 /*
  * hello-4.c - Demonstrates module documentation.
  */
-#include <linux/init.h>   /* Needed for the macros */
+#include <linux/init.h> /* Needed for the macros */
 #include <linux/kernel.h> /* Needed for pr_info() */
 #include <linux/module.h> /* Needed by all modules */
 

examples/hello-5.c

@@ -13,7 +13,7 @@ static short int myshort = 1;
 static int myint = 420;
 static long int mylong = 9999;
 static char *mystring = "blah";
-static int myintArray[2] = {420, 420};
+static int myintarray[2] = { 420, 420 };
 static int arr_argc = 0;
 
 /* module_param(foo, int, 0000)
@@ -38,22 +38,23 @@ MODULE_PARM_DESC(mystring, "A character string");
  * of elements of the array initialized by the user at module loading time.
  * The fourth argument is the permission bits.
  */
-module_param_array(myintArray, int, &arr_argc, 0000);
-MODULE_PARM_DESC(myintArray, "An array of integers");
+module_param_array(myintarray, int, &arr_argc, 0000);
+MODULE_PARM_DESC(myintarray, "An array of integers");
 
 static int __init hello_5_init(void)
 {
     int i;
+
     pr_info("Hello, world 5\n=============\n");
     pr_info("myshort is a short integer: %hd\n", myshort);
     pr_info("myint is an integer: %d\n", myint);
     pr_info("mylong is a long integer: %ld\n", mylong);
     pr_info("mystring is a string: %s\n", mystring);
 
-    for (i = 0; i < (sizeof myintArray / sizeof(int)); i++)
-        pr_info("myintArray[%d] = %d\n", i, myintArray[i]);
+    for (i = 0; i < ARRAY_SIZE(myintarray); i++)
+        pr_info("myintarray[%d] = %d\n", i, myintarray[i]);
 
-    pr_info("got %d arguments for myintArray.\n", arr_argc);
+    pr_info("got %d arguments for myintarray.\n", arr_argc);
     return 0;
 }
 

examples/hello-sysfs.c

@@ -14,24 +14,21 @@ static struct kobject *mymodule;
 static int myvariable = 0;
 
 static ssize_t myvariable_show(struct kobject *kobj,
-                               struct kobj_attribute *attr,
-                               char *buf)
+                               struct kobj_attribute *attr, char *buf)
 {
     return sprintf(buf, "%d\n", myvariable);
 }
 
 static ssize_t myvariable_store(struct kobject *kobj,
-                                struct kobj_attribute *attr,
-                                char *buf,
+                                struct kobj_attribute *attr, char *buf,
                                 size_t count)
 {
     sscanf(buf, "%du", &myvariable);
     return count;
 }
 
-
 static struct kobj_attribute myvariable_attribute =
-    __ATTR(myvariable, 0660, myvariable_show, (void *) myvariable_store);
+    __ATTR(myvariable, 0660, myvariable_show, (void *)myvariable_store);
 
 static int __init mymodule_init(void)
 {
@@ -45,9 +42,8 @@ static int __init mymodule_init(void)
 
     error = sysfs_create_file(mymodule, &myvariable_attribute.attr);
     if (error) {
-        pr_info(
-            "failed to create the myvariable file "
-            "in /sys/kernel/mymodule\n");
+        pr_info("failed to create the myvariable file "
+                "in /sys/kernel/mymodule\n");
     }
 
     return error;

examples/intrpt.c

@@ -13,18 +13,18 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 
-static int button_irqs[] = {-1, -1};
+static int button_irqs[] = { -1, -1 };
 
 /* Define GPIOs for LEDs.
  * TODO: Change the numbers for the GPIO on your board.
  */
-static struct gpio leds[] = {{4, GPIOF_OUT_INIT_LOW, "LED 1"}};
+static struct gpio leds[] = { { 4, GPIOF_OUT_INIT_LOW, "LED 1" } };
 
 /* Define GPIOs for BUTTONS
  * TODO: Change the numbers for the GPIO on your board.
  */
-static struct gpio buttons[] = {{17, GPIOF_IN, "LED 1 ON BUTTON"},
-                                {18, GPIOF_IN, "LED 1 OFF BUTTON"}};
+static struct gpio buttons[] = { { 17, GPIOF_IN, "LED 1 ON BUTTON" },
+                                 { 18, GPIOF_IN, "LED 1 OFF BUTTON" } };
 
 /* interrupt function triggered when a button is pressed. */
 static irqreturn_t button_isr(int irq, void *data)
@@ -83,7 +83,6 @@ static int __init intrpt_init(void)
         goto fail2;
     }
 
-
     ret = gpio_to_irq(buttons[1].gpio);
 
     if (ret < 0) {

examples/ioctl.c

@@ -35,8 +35,7 @@ struct test_ioctl_data {
     rwlock_t lock;
 };
 
-static long test_ioctl_ioctl(struct file *filp,
-                             unsigned int cmd,
+static long test_ioctl_ioctl(struct file *filp, unsigned int cmd,
                              unsigned long arg)
 {
     struct test_ioctl_data *ioctl_data = filp->private_data;
@@ -47,7 +46,7 @@ static long test_ioctl_ioctl(struct file *filp,
 
     switch (cmd) {
     case IOCTL_VALSET:
-        if (copy_from_user(&data, (int __user *) arg, sizeof(data))) {
+        if (copy_from_user(&data, (int __user *)arg, sizeof(data))) {
             retval = -EFAULT;
             goto done;
         }
@@ -64,7 +63,7 @@ static long test_ioctl_ioctl(struct file *filp,
         read_unlock(&ioctl_data->lock);
         data.val = val;
 
-        if (copy_to_user((int __user *) arg, &data, sizeof(data))) {
+        if (copy_to_user((int __user *)arg, &data, sizeof(data))) {
             retval = -EFAULT;
             goto done;
         }
@@ -72,7 +71,7 @@ static long test_ioctl_ioctl(struct file *filp,
         break;
 
     case IOCTL_VALGET_NUM:
-        retval = __put_user(ioctl_num, (int __user *) arg);
+        retval = __put_user(ioctl_num, (int __user *)arg);
         break;
 
     case IOCTL_VALSET_NUM:
@@ -87,15 +86,14 @@ done:
     return retval;
 }
 
-ssize_t test_ioctl_read(struct file *filp,
-                        char __user *buf,
-                        size_t count,
+ssize_t test_ioctl_read(struct file *filp, char __user *buf, size_t count,
                         loff_t *f_pos)
 {
     struct test_ioctl_data *ioctl_data = filp->private_data;
     unsigned char val;
     int retval;
     int i = 0;
+
     read_lock(&ioctl_data->lock);
     val = ioctl_data->val;
     read_unlock(&ioctl_data->lock);
@@ -127,16 +125,17 @@ static int test_ioctl_close(struct inode *inode, struct file *filp)
 static int test_ioctl_open(struct inode *inode, struct file *filp)
 {
     struct test_ioctl_data *ioctl_data;
+
     pr_alert("%s call.\n", __func__);
     ioctl_data = kmalloc(sizeof(struct test_ioctl_data), GFP_KERNEL);
 
-    if (ioctl_data == NULL) {
+    if (ioctl_data == NULL)
         return -ENOMEM;
-    }
 
     rwlock_init(&ioctl_data->lock);
     ioctl_data->val = 0xFF;
     filp->private_data = ioctl_data;
+
     return 0;
 }
 
@@ -155,37 +154,31 @@ static int ioctl_init(void)
     int cdev_ret = 0;
     alloc_ret = alloc_chrdev_region(&dev, 0, num_of_dev, DRIVER_NAME);
 
-    if (alloc_ret) {
+    if (alloc_ret)
         goto error;
-    }
 
     test_ioctl_major = MAJOR(dev);
     cdev_init(&test_ioctl_cdev, &fops);
     cdev_ret = cdev_add(&test_ioctl_cdev, dev, num_of_dev);
 
-    if (cdev_ret) {
+    if (cdev_ret)
         goto error;
-    }
 
     pr_alert("%s driver(major: %d) installed.\n", DRIVER_NAME,
              test_ioctl_major);
     return 0;
 error:
-
-    if (cdev_ret == 0) {
+    if (cdev_ret == 0)
         cdev_del(&test_ioctl_cdev);
-    }
-
-    if (alloc_ret == 0) {
+    if (alloc_ret == 0)
         unregister_chrdev_region(dev, num_of_dev);
-    }
-
     return -1;
 }
 
 static void ioctl_exit(void)
 {
     dev_t dev = MKDEV(test_ioctl_major, 0);
+
     cdev_del(&test_ioctl_cdev);
     unregister_chrdev_region(dev, num_of_dev);
     pr_alert("%s driver removed.\n", DRIVER_NAME);

examples/kbleds.c

@@ -35,7 +35,7 @@ char kbledstatus = 0;
 
 static void my_timer_func(unsigned long ptr)
 {
-    unsigned long *pstatus = (unsigned long *) ptr;
+    unsigned long *pstatus = (unsigned long *)ptr;
     struct tty_struct *t = vc_cons[fg_console].d->port.tty;
 
     if (*pstatus == ALL_LEDS_ON)
@@ -59,7 +59,7 @@ static int __init kbleds_init(void)
         if (!vc_cons[i].d)
             break;
         pr_info("poet_atkm: console[%i/%i] #%i, tty %lx\n", i, MAX_NR_CONSOLES,
-                vc_cons[i].d->vc_num, (unsigned long) vc_cons[i].d->port.tty);
+                vc_cons[i].d->vc_num, (unsigned long)vc_cons[i].d->port.tty);
     }
     pr_info("kbleds: finished scanning consoles\n");
 
@@ -67,8 +67,7 @@ static int __init kbleds_init(void)
     pr_info("kbleds: tty driver magic %x\n", my_driver->magic);
 
     /* Set up the LED blink timer the first time. */
-    timer_setup(&my_timer, (void *) &my_timer_func,
-                (unsigned long) &kbledstatus);
+    timer_setup(&my_timer, (void *)&my_timer_func, (unsigned long)&kbledstatus);
     my_timer.expires = jiffies + BLINK_DELAY;
     add_timer(&my_timer);
 

examples/print_string.c

@@ -7,7 +7,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/sched.h> /* For current */
-#include <linux/tty.h>   /* For the tty declarations */
+#include <linux/tty.h> /* For the tty declarations */
 
 static void print_string(char *str)
 {
@@ -37,8 +37,8 @@ static void print_string(char *str)
          * section 2 of
          * linux/Documentation/SubmittingPatches
          */
-        (ttyops->write)(my_tty,       /* The tty itself */
-                        str,          /* String                 */
+        (ttyops->write)(my_tty, /* The tty itself */
+                        str, /* String */
                         strlen(str)); /* Length */
 
         /* ttys were originally hardware devices, which (usually) strictly

examples/procfs1.c

@@ -14,13 +14,10 @@
 
 #define procfs_name "helloworld"
 
-struct proc_dir_entry *Our_Proc_File;
+struct proc_dir_entry *our_proc_file;
 
-
-ssize_t procfile_read(struct file *filePointer,
-                      char *buffer,
-                      size_t buffer_length,
-                      loff_t *offset)
+ssize_t procfile_read(struct file *filePointer, char *buffer,
+                      size_t buffer_length, loff_t *offset)
 {
     char s[13] = "HelloWorld!\n";
     int len = sizeof(s);
@@ -49,9 +46,9 @@ static const struct file_operations proc_file_fops = {
 
 static int __init procfs1_init(void)
 {
-    Our_Proc_File = proc_create(procfs_name, 0644, NULL, &proc_file_fops);
-    if (NULL == Our_Proc_File) {
-        proc_remove(Our_Proc_File);
+    our_proc_file = proc_create(procfs_name, 0644, NULL, &proc_file_fops);
+    if (NULL == our_proc_file) {
+        proc_remove(our_proc_file);
         pr_alert("Error:Could not initialize /proc/%s\n", procfs_name);
         return -ENOMEM;
     }
@@ -62,7 +59,7 @@ static int __init procfs1_init(void)
 
 static void __exit procfs1_exit(void)
 {
-    proc_remove(Our_Proc_File);
+    proc_remove(our_proc_file);
     pr_info("/proc/%s removed\n", procfs_name);
 }
 

examples/procfs2.c

@@ -2,8 +2,8 @@
  * procfs2.c -  create a "file" in /proc
  */
 
-#include <linux/kernel.h>  /* We're doing kernel work */
-#include <linux/module.h>  /* Specifically, a module */
+#include <linux/kernel.h> /* We're doing kernel work */
+#include <linux/module.h> /* Specifically, a module */
 #include <linux/proc_fs.h> /* Necessary because we use the proc fs */
 #include <linux/uaccess.h> /* for copy_from_user */
 #include <linux/version.h>
@@ -16,7 +16,7 @@
 #define PROCFS_NAME "buffer1k"
 
 /* This structure hold information about the /proc file */
-static struct proc_dir_entry *Our_Proc_File;
+static struct proc_dir_entry *our_proc_file;
 
 /* The buffer used to store character for this module */
 static char procfs_buffer[PROCFS_MAX_SIZE];
@@ -25,10 +25,8 @@ static char procfs_buffer[PROCFS_MAX_SIZE];
 static unsigned long procfs_buffer_size = 0;
 
 /* This function is called then the /proc file is read */
-ssize_t procfile_read(struct file *filePointer,
-                      char *buffer,
-                      size_t buffer_length,
-                      loff_t *offset)
+ssize_t procfile_read(struct file *filePointer, char *buffer,
+                      size_t buffer_length, loff_t *offset)
 {
     char s[13] = "HelloWorld!\n";
     int len = sizeof(s);
@@ -46,9 +44,7 @@ ssize_t procfile_read(struct file *filePointer,
 }
 
 /* This function is called with the /proc file is written. */
-static ssize_t procfile_write(struct file *file,
-                              const char *buff,
-                              size_t len,
+static ssize_t procfile_write(struct file *file, const char *buff, size_t len,
                               loff_t *off)
 {
     procfs_buffer_size = len;
@@ -76,9 +72,9 @@ static const struct file_operations proc_file_fops = {
 
 static int __init procfs2_init(void)
 {
-    Our_Proc_File = proc_create(PROCFS_NAME, 0644, NULL, &proc_file_fops);
-    if (NULL == Our_Proc_File) {
-        proc_remove(Our_Proc_File);
+    our_proc_file = proc_create(PROCFS_NAME, 0644, NULL, &proc_file_fops);
+    if (NULL == our_proc_file) {
+        proc_remove(our_proc_file);
         pr_alert("Error:Could not initialize /proc/%s\n", PROCFS_NAME);
         return -ENOMEM;
     }
@@ -89,7 +85,7 @@ static int __init procfs2_init(void)
 
 static void __exit procfs2_exit(void)
 {
-    proc_remove(Our_Proc_File);
+    proc_remove(our_proc_file);
     pr_info("/proc/%s removed\n", PROCFS_NAME);
 }
 

examples/procfs3.c

@@ -16,30 +16,29 @@
 #define PROCFS_MAX_SIZE 2048
 #define PROCFS_ENTRY_FILENAME "buffer2k"
 
-struct proc_dir_entry *Our_Proc_File;
+struct proc_dir_entry *our_proc_file;
 static char procfs_buffer[PROCFS_MAX_SIZE];
 static unsigned long procfs_buffer_size = 0;
 
-static ssize_t procfs_read(struct file *filp,
-                           char *buffer,
-                           size_t length,
+static ssize_t procfs_read(struct file *filp, char *buffer, size_t length,
                            loff_t *offset)
 {
     static int finished = 0;
+
     if (finished) {
         pr_debug("procfs_read: END\n");
         finished = 0;
         return 0;
     }
     finished = 1;
+
     if (copy_to_user(buffer, procfs_buffer, procfs_buffer_size))
         return -EFAULT;
+
     pr_debug("procfs_read: read %lu bytes\n", procfs_buffer_size);
     return procfs_buffer_size;
 }
-static ssize_t procfs_write(struct file *file,
-                            const char *buffer,
-                            size_t len,
+static ssize_t procfs_write(struct file *file, const char *buffer, size_t len,
                             loff_t *off)
 {
     if (len > PROCFS_MAX_SIZE)
@@ -48,6 +47,7 @@ static ssize_t procfs_write(struct file *file,
         procfs_buffer_size = len;
     if (copy_from_user(procfs_buffer, buffer, procfs_buffer_size))
         return -EFAULT;
+
     pr_debug("procfs_write: write %lu bytes\n", procfs_buffer_size);
     return procfs_buffer_size;
 }
@@ -63,14 +63,14 @@ int procfs_close(struct inode *inode, struct file *file)
 }
 
 #ifdef HAVE_PROC_OPS
-static struct proc_ops File_Ops_4_Our_Proc_File = {
+static struct proc_ops file_ops_4_our_proc_file = {
     .proc_read = procfs_read,
     .proc_write = procfs_write,
     .proc_open = procfs_open,
     .proc_release = procfs_close,
 };
 #else
-static const struct file_operations File_Ops_4_Our_Proc_File = {
+static const struct file_operations file_ops_4_our_proc_file = {
     .read = procfs_read,
     .write = procfs_write,
     .open = procfs_open,
@@ -80,16 +80,16 @@ static const struct file_operations File_Ops_4_Our_Proc_File = {
 
 static int __init procfs3_init(void)
 {
-    Our_Proc_File = proc_create(PROCFS_ENTRY_FILENAME, 0644, NULL,
-                                &File_Ops_4_Our_Proc_File);
-    if (Our_Proc_File == NULL) {
+    our_proc_file = proc_create(PROCFS_ENTRY_FILENAME, 0644, NULL,
+                                &file_ops_4_our_proc_file);
+    if (our_proc_file == NULL) {
         remove_proc_entry(PROCFS_ENTRY_FILENAME, NULL);
         pr_debug("Error: Could not initialize /proc/%s\n",
                  PROCFS_ENTRY_FILENAME);
         return -ENOMEM;
     }
-    proc_set_size(Our_Proc_File, 80);
-    proc_set_user(Our_Proc_File, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID);
+    proc_set_size(our_proc_file, 80);
+    proc_set_user(our_proc_file, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID);
 
     pr_debug("/proc/%s created\n", PROCFS_ENTRY_FILENAME);
     return 0;

examples/procfs4.c

@@ -3,9 +3,9 @@
  * This program uses the seq_file library to manage the /proc file.
  */
 
-#include <linux/kernel.h>   /* We are doing kernel work */
-#include <linux/module.h>   /* Specifically, a module */
-#include <linux/proc_fs.h>  /* Necessary because we use proc fs */
+#include <linux/kernel.h> /* We are doing kernel work */
+#include <linux/module.h> /* Specifically, a module */
+#include <linux/proc_fs.h> /* Necessary because we use proc fs */
 #include <linux/seq_file.h> /* for seq_file */
 #include <linux/version.h>
 
@@ -29,6 +29,7 @@ static void *my_seq_start(struct seq_file *s, loff_t *pos)
         /* yes => return a non null value to begin the sequence */
         return &counter;
     }
+
     /* no => it is the end of the sequence, return end to stop reading */
     *pos = 0;
     return NULL;
@@ -39,7 +40,7 @@ static void *my_seq_start(struct seq_file *s, loff_t *pos)
  */
 static void *my_seq_next(struct seq_file *s, void *v, loff_t *pos)
 {
-    unsigned long *tmp_v = (unsigned long *) v;
+    unsigned long *tmp_v = (unsigned long *)v;
     (*tmp_v)++;
     (*pos)++;
     return NULL;
@@ -54,7 +55,7 @@ static void my_seq_stop(struct seq_file *s, void *v)
 /* This function is called for each "step" of a sequence. */
 static int my_seq_show(struct seq_file *s, void *v)
 {
-    loff_t *spos = (loff_t *) v;
+    loff_t *spos = (loff_t *)v;
 
     seq_printf(s, "%Ld\n", *spos);
     return 0;

examples/sched.c

@@ -18,7 +18,6 @@ static int __init sched_init(void)
     queue = alloc_workqueue("HELLOWORLD", WQ_UNBOUND, 1);
     INIT_WORK(&work, work_handler);
     schedule_work(&work);
-
     return 0;
 }
 

examples/sleep.c

@@ -3,10 +3,10 @@
  * at the same time, put all but one to sleep.
  */
 
-#include <linux/kernel.h>  /* We're doing kernel work */
-#include <linux/module.h>  /* Specifically, a module */
+#include <linux/kernel.h> /* We're doing kernel work */
+#include <linux/module.h> /* Specifically, a module */
 #include <linux/proc_fs.h> /* Necessary because we use proc fs */
-#include <linux/sched.h>   /* For putting processes to sleep and
+#include <linux/sched.h> /* For putting processes to sleep and
                                    waking them up */
 #include <linux/uaccess.h> /* for get_user and put_user */
 #include <linux/version.h>
@@ -19,9 +19,9 @@
  * input.
  */
 #define MESSAGE_LENGTH 80
-static char Message[MESSAGE_LENGTH];
+static char message[MESSAGE_LENGTH];
 
-static struct proc_dir_entry *Our_Proc_File;
+static struct proc_dir_entry *our_proc_file;
 #define PROC_ENTRY_FILENAME "sleep"
 
 /* Since we use the file operations struct, we can't use the special proc
@@ -29,14 +29,14 @@ static struct proc_dir_entry *Our_Proc_File;
  * function.
  */
 static ssize_t module_output(struct file *file, /* see include/linux/fs.h   */
-                             char *buf,         /* The buffer to put data to
+                             char *buf, /* The buffer to put data to
                                                    (in the user segment)    */
-                             size_t len,        /* The length of the buffer */
+                             size_t len, /* The length of the buffer */
                              loff_t *offset)
 {
     static int finished = 0;
     int i;
-    char message[MESSAGE_LENGTH + 30];
+    char output_msg[MESSAGE_LENGTH + 30];
 
     /* Return 0 to signify end of file - that we have nothing more to say
      * at this point.
@@ -46,9 +46,9 @@ static ssize_t module_output(struct file *file, /* see include/linux/fs.h   */
         return 0;
     }
 
-    sprintf(message, "Last input:%s\n", Message);
-    for (i = 0; i < len && message[i]; i++)
-        put_user(message[i], buf + i);
+    sprintf(output_msg, "Last input:%s\n", message);
+    for (i = 0; i < len && output_msg[i]; i++)
+        put_user(output_msg[i], buf + i);
 
     finished = 1;
     return i; /* Return the number of bytes "read" */
@@ -58,9 +58,9 @@ static ssize_t module_output(struct file *file, /* see include/linux/fs.h   */
  * /proc file.
  */
 static ssize_t module_input(struct file *file, /* The file itself */
-                            const char *buf,   /* The buffer with input */
-                            size_t length,     /* The buffer's length */
-                            loff_t *offset)    /* offset to file - ignore */
+                            const char *buf, /* The buffer with input */
+                            size_t length, /* The buffer's length */
+                            loff_t *offset) /* offset to file - ignore */
 {
     int i;
 
@@ -68,19 +68,19 @@ static ssize_t module_input(struct file *file, /* The file itself */
      * to use it.
      */
     for (i = 0; i < MESSAGE_LENGTH - 1 && i < length; i++)
-        get_user(Message[i], buf + i);
+        get_user(message[i], buf + i);
     /* we want a standard, zero terminated string */
-    Message[i] = '\0';
+    message[i] = '\0';
 
     /* We need to return the number of input characters used */
     return i;
 }
 
 /* 1 if the file is currently open by somebody */
-int Already_Open = 0;
+int already_open = 0;
 
 /* Queue of processes who want our file */
-DECLARE_WAIT_QUEUE_HEAD(WaitQ);
+DECLARE_WAIT_QUEUE_HEAD(waitq);
 
 /* Called when the /proc file is opened */
 static int module_open(struct inode *inode, struct file *file)
@@ -90,7 +90,7 @@ static int module_open(struct inode *inode, struct file *file)
      * we should fail with -EAGAIN, meaning "you will have to try again",
      * instead of blocking a process which would rather stay awake.
      */
-    if ((file->f_flags & O_NONBLOCK) && Already_Open)
+    if ((file->f_flags & O_NONBLOCK) && already_open)
         return -EAGAIN;
 
     /* This is the correct place for try_module_get(THIS_MODULE) because if
@@ -100,17 +100,17 @@ static int module_open(struct inode *inode, struct file *file)
     try_module_get(THIS_MODULE);
 
     /* If the file is already open, wait until it is not. */
-    while (Already_Open) {
+    while (already_open) {
         int i, is_sig = 0;
 
         /* This function puts the current process, including any system
          * calls, such as us, to sleep.  Execution will be resumed right
          * after the function call, either because somebody called
-         * wake_up(&WaitQ) (only module_close does that, when the file
+         * wake_up(&waitq) (only module_close does that, when the file
          * is closed) or when a signal, such as Ctrl-C, is sent
          * to the process
          */
-        wait_event_interruptible(WaitQ, !Already_Open);
+        wait_event_interruptible(waitq, !already_open);
 
         /* If we woke up because we got a signal we're not blocking,
          * return -EINTR (fail the system call).  This allows processes
@@ -133,27 +133,27 @@ static int module_open(struct inode *inode, struct file *file)
         }
     }
 
-    /* If we got here, Already_Open must be zero. */
+    /* If we got here, already_open must be zero. */
 
     /* Open the file */
-    Already_Open = 1;
+    already_open = 1;
     return 0; /* Allow the access */
 }
 
 /* Called when the /proc file is closed */
 int module_close(struct inode *inode, struct file *file)
 {
-    /* Set Already_Open to zero, so one of the processes in the WaitQ will
-     * be able to set Already_Open back to one and to open the file. All
-     * the other processes will be called when Already_Open is back to one,
+    /* Set already_open to zero, so one of the processes in the waitq will
+     * be able to set already_open back to one and to open the file. All
+     * the other processes will be called when already_open is back to one,
      * so they'll go back to sleep.
      */
-    Already_Open = 0;
+    already_open = 0;
 
-    /* Wake up all the processes in WaitQ, so if anybody is waiting for the
+    /* Wake up all the processes in waitq, so if anybody is waiting for the
      * file, they can have it.
      */
-    wake_up(&WaitQ);
+    wake_up(&waitq);
 
     module_put(THIS_MODULE);
 
@@ -169,14 +169,14 @@ int module_close(struct inode *inode, struct file *file)
  * means we don't want to deal with something.
  */
 #ifdef HAVE_PROC_OPS
-static const struct proc_ops File_Ops_4_Our_Proc_File = {
-    .proc_read = module_output,   /* "read" from the file */
-    .proc_write = module_input,   /* "write" to the file */
-    .proc_open = module_open,     /* called when the /proc file is opened */
+static const struct proc_ops file_ops_4_our_proc_file = {
+    .proc_read = module_output, /* "read" from the file */
+    .proc_write = module_input, /* "write" to the file */
+    .proc_open = module_open, /* called when the /proc file is opened */
     .proc_release = module_close, /* called when it's closed */
 };
 #else
-static const struct file_operations File_Ops_4_Our_Proc_File = {
+static const struct file_operations file_ops_4_our_proc_file = {
     .read = module_output,
     .write = module_input,
     .open = module_open,
@@ -187,15 +187,15 @@ static const struct file_operations File_Ops_4_Our_Proc_File = {
 /* Initialize the module - register the proc file */
 static int __init sleep_init(void)
 {
-    Our_Proc_File =
-        proc_create(PROC_ENTRY_FILENAME, 0644, NULL, &File_Ops_4_Our_Proc_File);
-    if (Our_Proc_File == NULL) {
+    our_proc_file =
+        proc_create(PROC_ENTRY_FILENAME, 0644, NULL, &file_ops_4_our_proc_file);
+    if (our_proc_file == NULL) {
         remove_proc_entry(PROC_ENTRY_FILENAME, NULL);
         pr_debug("Error: Could not initialize /proc/%s\n", PROC_ENTRY_FILENAME);
         return -ENOMEM;
     }
-    proc_set_size(Our_Proc_File, 80);
-    proc_set_user(Our_Proc_File, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID);
+    proc_set_size(our_proc_file, 80);
+    proc_set_user(our_proc_file, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID);
 
     pr_info("/proc/%s created\n", PROC_ENTRY_FILENAME);
 
@@ -203,7 +203,7 @@ static int __init sleep_init(void)
 }
 
 /* Cleanup - unregister our file from /proc.  This could get dangerous if
- * there are still processes waiting in WaitQ, because they are inside our
+ * there are still processes waiting in waitq, because they are inside our
  * open function, which will get unloaded. I'll explain how to avoid removal
  * of a kernel module in such a case in chapter 10.
  */

examples/syscall.c

@@ -14,7 +14,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h> /* which will have params */
-#include <linux/unistd.h>      /* The list of system calls */
+#include <linux/unistd.h> /* The list of system calls */
 #include <linux/version.h>
 
 /* For the current (process) structure, we need this to know who the
@@ -23,7 +23,6 @@
 #include <linux/sched.h>
 #include <linux/uaccess.h>
 
-
 /* The way we access "sys_call_table" varies as kernel internal changes.
  * - ver <= 5.4 : manual symbol lookup
  * - 5.4 < ver < 5.7 : kallsyms_lookup_name
@@ -56,9 +55,9 @@
  */
 static unsigned long sym = 0;
 module_param(sym, ulong, 0644);
-#endif
+#endif /* CONFIG_KPROBES */
 
-#endif
+#endif /* Version < v5.7 */
 
 unsigned long **sys_call_table;
 
@@ -115,9 +114,9 @@ static unsigned long **aquire_sys_call_table(void)
     unsigned long **sct;
 
     while (offset < ULLONG_MAX) {
-        sct = (unsigned long **) offset;
+        sct = (unsigned long **)offset;
 
-        if (sct[__NR_close] == (unsigned long *) ksys_close)
+        if (sct[__NR_close] == (unsigned long *)ksys_close)
             return sct;
 
         offset += sizeof(void *);
@@ -128,23 +127,20 @@ static unsigned long **aquire_sys_call_table(void)
 
 #ifdef HAVE_PARAM
     const char sct_name[15] = "sys_call_table";
-    char symbol[40] = {0};
+    char symbol[40] = { 0 };
 
     if (sym == 0) {
-        pr_alert(
-            "For Linux v5.7+, Kprobes is the preferable way to get "
-            "symbol.\n");
-        pr_info(
-            "If Kprobes is absent, you have to specify the address of "
-            "sys_call_table symbol\n");
-        pr_info(
-            "by /boot/System.map or /proc/kallsyms, which contains all the "
-            "symbol addresses, into sym parameter.\n");
+        pr_alert("For Linux v5.7+, Kprobes is the preferable way to get "
+                 "symbol.\n");
+        pr_info("If Kprobes is absent, you have to specify the address of "
+                "sys_call_table symbol\n");
+        pr_info("by /boot/System.map or /proc/kallsyms, which contains all the "
+                "symbol addresses, into sym parameter.\n");
         return NULL;
     }
     sprint_symbol(symbol, sym);
     if (!strncmp(sct_name, symbol, sizeof(sct_name) - 1))
-        return (unsigned long **) sym;
+        return (unsigned long **)sym;
 
     return NULL;
 #endif
@@ -157,11 +153,11 @@ static unsigned long **aquire_sys_call_table(void)
 
     if (register_kprobe(&kp) < 0)
         return NULL;
-    kallsyms_lookup_name = (unsigned long (*)(const char *name)) kp.addr;
+    kallsyms_lookup_name = (unsigned long (*)(const char *name))kp.addr;
     unregister_kprobe(&kp);
 #endif
 
-    return (unsigned long **) kallsyms_lookup_name("sys_call_table");
+    return (unsigned long **)kallsyms_lookup_name("sys_call_table");
 }
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 3, 0)
@@ -195,10 +191,10 @@ static int __init syscall_start(void)
     disable_write_protection();
 
     /* keep track of the original open function */
-    original_call = (void *) sys_call_table[__NR_open];
+    original_call = (void *)sys_call_table[__NR_open];
 
     /* use our open function instead */
-    sys_call_table[__NR_open] = (unsigned long *) our_sys_open;
+    sys_call_table[__NR_open] = (unsigned long *)our_sys_open;
 
     enable_write_protection();
 
@@ -213,7 +209,7 @@ static void __exit syscall_end(void)
         return;
 
     /* Return the system call back to normal */
-    if (sys_call_table[__NR_open] != (unsigned long *) our_sys_open) {
+    if (sys_call_table[__NR_open] != (unsigned long *)our_sys_open) {
         pr_alert("Somebody else also played with the ");
         pr_alert("open system call\n");
         pr_alert("The system may be left in ");
@@ -221,7 +217,7 @@ static void __exit syscall_end(void)
     }
 
     disable_write_protection();
-    sys_call_table[__NR_open] = (unsigned long *) original_call;
+    sys_call_table[__NR_open] = (unsigned long *)original_call;
     enable_write_protection();
 
     msleep(2000);