Enable sysfs to send data from user to kernel

We wish to achieve full interactivity between user space and kernel
space, which means we can manipulate the displaying status, restart and
ending choice for the tic-tac-toe games between kernel theads from user
space.

We doing so by establish device attribute through "DEVICE_ATTR_RW()" so
we can interact with kernel from user space by reading or writing
contents into a file under sysfs.

Author: vax-r

kmldrv-user.c

@@ -1,14 +1,17 @@
+#include <fcntl.h>
 #include <getopt.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <termios.h>
 #include <unistd.h>
 
 #include "game.h"
 
 #define KMLDRV_STATUS_FILE "/sys/module/kmldrv/initstate"
 #define KMLDRV_DEVICE_FILE "/dev/kmldrv"
+#define KMLDRV_DEVICE_ATTR_FILE "/sys/class/kmldrv/kmldrv/kmldrv_state"
 
 bool kmldrv_status_check(void)
 {
@@ -32,6 +35,21 @@ bool kmldrv_status_check(void)
     return true;
 }
 
+static struct termios orig_termios;
+
+static void disableRawMode(void)
+{
+    tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_termios);
+}
+
+static void enableRawMode(void)
+{
+    tcgetattr(STDIN_FILENO, &orig_termios);
+    atexit(disableRawMode);
+    struct termios raw = orig_termios;
+    raw.c_lflag &= ~(ECHO | ICANON);
+    tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
+}
 
 int main(int argc, char *argv[])
 {
@@ -63,13 +81,37 @@ int main(int argc, char *argv[])
     if (!kmldrv_status_check())
         exit(1);
 
+    enableRawMode();
+    int flags = fcntl(STDIN_FILENO, F_GETFL, 0);
+    fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);
+
     FILE *device_ptr = fopen(KMLDRV_DEVICE_FILE, "r");
     char display_buf[DRAWBUFFER_SIZE];
+
+    int attr_fd = open(KMLDRV_DEVICE_ATTR_FILE, O_WRONLY);
+    char input;
     while (fgets(display_buf, DRAWBUFFER_SIZE, device_ptr)) {
         printf("%s", display_buf);
+
+        if (read(STDIN_FILENO, &input, 1) == 1) {
+            switch (input) {
+            case 16:
+                char buf[20];
+                read(attr_fd, buf, 5);
+                buf[0] = (buf[0] - '0') ? '0' : '1';
+                write(attr_fd, buf, 5);
+                break;
+            case 17:
+                break;
+            }
+        }
     }
 
+    disableRawMode();
+    fcntl(STDIN_FILENO, F_SETFL, flags);
+
     fclose(device_ptr);
+    close(attr_fd);
 
     return 0;
 }

scripts/pre-commit.hook

@@ -4,7 +4,8 @@ CPPCHECK_suppresses="--suppress=unmatchedSuppression \
 --suppress=missingIncludeSystem -i ksort.mod.c --suppress=variableScope \
 --suppress=unmatchedSuppression:simrupt.c \
 --suppress=constParameterPointer:simrupt.c \
---suppress=constParameterCallback:simrupt.c"
+--suppress=constParameterCallback:simrupt.c \
+--suppress=unusedFunction:simrupt.c"
 CPPCHECK_OPTS="-I. --enable=all --error-exitcode=1 --force $CPPCHECK_suppresses ."
 
 RETURN=0

simrupt.c

@@ -8,6 +8,7 @@
 #include <linux/kfifo.h>
 #include <linux/module.h>
 #include <linux/slab.h>
+#include <linux/sysfs.h>
 #include <linux/version.h>
 #include <linux/workqueue.h>
 
@@ -32,6 +33,42 @@ MODULE_DESCRIPTION("A device that simulates interrupts");
 
 static int delay = 100; /* time (in ms) to generate an event */
 
+/* Declare kernel module attribute for sysfs */
+
+struct kmldrv_attr {
+    char display;
+    char restart;
+    char end;
+    rwlock_t lock;
+};
+
+static struct kmldrv_attr attr_obj;
+
+static ssize_t kmldrv_state_show(struct device *dev,
+                                 struct device_attribute *attr,
+                                 char *buf)
+{
+    read_lock(&attr_obj.lock);
+    int ret = snprintf(buf, 6, "%c %c %c\n", attr_obj.display, attr_obj.restart,
+                       attr_obj.end);
+    read_unlock(&attr_obj.lock);
+    return ret;
+}
+
+static ssize_t kmldrv_state_store(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf,
+                                  size_t count)
+{
+    write_lock(&attr_obj.lock);
+    sscanf(buf, "%c %c %c", &(attr_obj.display), &(attr_obj.restart),
+           &(attr_obj.end));
+    write_unlock(&attr_obj.lock);
+    return count;
+}
+
+static DEVICE_ATTR_RW(kmldrv_state);
+
 /* Data produced by the simulated device */
 
 /* Timer to simulate a periodic IRQ */
@@ -135,16 +172,21 @@ static void drawboard_work_func(struct work_struct *w)
     pr_info("kmldrv: [CPU#%d] %s\n", cpu, __func__);
     put_cpu();
 
+    read_lock(&attr_obj.lock);
+    if (attr_obj.display == '0') {
+        read_unlock(&attr_obj.lock);
+        return;
+    }
+    read_unlock(&attr_obj.lock);
+
     mutex_lock(&producer_lock);
     draw_board(table);
     mutex_unlock(&producer_lock);
 
     /* Store data to the kfifo buffer */
-    // mutex_lock(&producer_lock);
     mutex_lock(&consumer_lock);
     produce_board();
     mutex_unlock(&consumer_lock);
-    // mutex_unlock(&producer_lock);
 
     wake_up_interruptible(&rx_wait);
 }
@@ -300,24 +342,28 @@ static void timer_handler(struct timer_list *__timer)
 
     if (win == ' ') {
         ai_game();
-        mod_timer(&timer, jiffies + msecs_to_jiffies(delay));
     } else {
-        int cpu = get_cpu();
-        pr_info("kmldrv: [CPU#%d] Drawing final board\n", cpu);
-        put_cpu();
-
-        mutex_lock(&producer_lock);
-        draw_board(table);
-        mutex_unlock(&producer_lock);
-
-        /* Store data to the kfifo buffer */
-        mutex_lock(&consumer_lock);
-        produce_board();
-        mutex_unlock(&consumer_lock);
-
-        wake_up_interruptible(&rx_wait);
+        read_lock(&attr_obj.lock);
+        if (attr_obj.display == '1') {
+            int cpu = get_cpu();
+            pr_info("kmldrv: [CPU#%d] Drawing final board\n", cpu);
+            put_cpu();
+
+            mutex_lock(&producer_lock);
+            draw_board(table);
+            mutex_unlock(&producer_lock);
+
+            /* Store data to the kfifo buffer */
+            mutex_lock(&consumer_lock);
+            produce_board();
+            mutex_unlock(&consumer_lock);
+
+            wake_up_interruptible(&rx_wait);
+        }
+        read_unlock(&attr_obj.lock);
 
         pr_info("kmldrv: %c win!!!\n", win);
+        memset(table, ' ', N_GRIDS); /* Reset the table so the game restart */
     }
     tv_end = ktime_get();
 
@@ -326,6 +372,8 @@ static void timer_handler(struct timer_list *__timer)
     pr_info("kmldrv: [CPU#%d] %s in_irq: %llu usec\n", smp_processor_id(),
             __func__, (unsigned long long) nsecs >> 10);
 
+    mod_timer(&timer, jiffies + msecs_to_jiffies(delay));
+
     local_irq_enable();
 }
 
@@ -433,7 +481,14 @@ static int __init kmldrv_init(void)
     }
 
     /* Register the device with sysfs */
-    device_create(kmldrv_class, NULL, MKDEV(major, 0), NULL, DEV_NAME);
+    struct device *kmldrv_dev =
+        device_create(kmldrv_class, NULL, MKDEV(major, 0), NULL, DEV_NAME);
+
+    ret = device_create_file(kmldrv_dev, &dev_attr_kmldrv_state);
+    if (ret < 0) {
+        printk(KERN_ERR "failed to create sysfs file kmldrv_state\n");
+        goto error_cdev;
+    }
 
     /* Allocate fast circular buffer */
     fast_buf.buf = vmalloc(PAGE_SIZE);
@@ -458,6 +513,11 @@ static int __init kmldrv_init(void)
     memset(table, ' ', N_GRIDS);
     turn = 'O';
     finish = 1;
+
+    attr_obj.display = '1';
+    attr_obj.restart = '0';
+    attr_obj.end = '0';
+    rwlock_init(&attr_obj.lock);
     /* Setup the timer */
     timer_setup(&timer, timer_handler, 0);
     atomic_set(&open_cnt, 0);