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

Author: linD026

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