Creating a misc characther device and reading from it

Linux has misc devices which meant for small device drivers. According to the article written by Alessandro Rubini Miscellaneous Character Drivers :

Sometimes people need to write “small” device drivers, to support custom hacks—either hardware or software ones. To this end, as well as to host some real drivers, the Linux kernel exports an interface to allow modules to register their own small drivers. The misc driver was designed for this purpose.

miscdevice is declared as the structure in miscdevice.h

struct miscdevice { int minor; const char *name; const struct file_operations *fops; struct list_head list; struct device *parent; struct device *this_device; const struct attribute_group **groups; const char *nodename; umode_t mode; };

For this example we will just use the first three fields.

minor: Minor number assigned to the device name: The name by which the device will be known fops: The file_operations structure mapped to the the device.

The name of the device can be any name that the user wants. The minor number can be statically assigned by the user , if it has to be dynamically assigned by the user , the value has to be set to `MISC_DYNAMIC_MINOR.

Thus our device structure will look as below.

struct miscdevice my_misc = { .minor = MISC_DYNAMIC_MINOR, .name="mymisc", .fops = &myfops, };

To register a misc device the function used is

int misc_register ( struct miscdevice * misc); where struct miscdevice * misc: device structure

We can create a characther string which will hold the data for now which will be sent out everytime the device is read. Thus we create a function to fill the data for the device.

void fill_data(void) { msg=kmalloc(10*sizeof(char),GFP_KERNEL); msg="hello"; len=strlen(msg); size=sizeof(char)*len; return 0; }

The init function for the device will have to register the device. Unlike a charachter device, we dont need to get a major number for a misc device as the default major number for misc devices is 10. To see the minor number which will be assigned dynamically we will add a print statement to get the minor number.

int misc_init(void) { misc_register(&my_misc); printk(KERN_INFO "registered device %d",my_misc.minor); return 0; }

We will create two file operations for this, one to open the device and one to read from the device. Thus the file operations structure will be

struct file_operations myfops = { .open = misc_open, .read = misc_read, };

The open function will fill data into the device,which we can read using the read function.

static int misc_open(struct inode *inode, struct file *file) { printk(KERN_INFO "Opening misc device\n"); fill_data(); return 0; }

The read function will copy the contents of the device to the userspace.

static ssize_t misc_read(struct file *file, char __user *buf, size_t count, loff_t *offp){ int temp,ret=size; if(size) { temp=copy_to_user(buf,msg,size); size=size-(size-temp ); printk(KERN_INFO "Reading device"); } return ret; }

Thus the full code misc device will be



Save the above code as misc_device_read.c

Use the following makefile to compile the code.

ifneq ($(KERNELRELEASE),) obj-m := misc_device_read.o else KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules clean: $(MAKE) -C $(KERNELDIR) M=$(PWD) clean endif

Compile and insert the code using

$ make $ insmod misc_device_read.ko

To see the minor number allocated to the device, use dmesg

$ dmesg | tail -1 [ 515.426861] registered device 55

We can also view the minor number and find if the device got registered succssfully by looking into the file /proc/misc

55 mymisc 229 fuse 56 vsock 57 rfkill 58 vmci 235 autofs 59 memory_bandwidth 60 network_throughput 61 network_latency 62 cpu_dma_latency 1 psaux 175 agpgart 228 hpet 231 snapshot 63 vga_arbiter

The device will automatically get listed under /dev which we can view using the ls command.

$ ls -l /dev/mymisc crw------- 1 root root 10, 55 Mar 30 04:08 /dev/mymisc1

We can see that the major number is 10 and the minor number is 55.

To read the device, we can use the cat command.

$ cat /dev/mymisc hello

Using average and averagea in libreoffice

If we want to find the average of values in a column in libreoffice, and the column has mix of numbers and characters we can use the function "AVERAGE" which takes input the range of cells ,but the drawback is that the function does not count the cells that have characters.

Let us say we have the following file and the column labelled "data" has a mix of numbers and characters.

Using the function "AVERAGE" we will get the average of 1,2,3,4 as 2.5,which is (1+2+3+4)/4. Though there were 2 cells having characters, the function did not consider them and gave an average as if it was for 4 cells.

On the other hand, if we wanted to calculate the average as if the two character cells were 0, and take the number of cells to be 6. We can use the function "AVERAGEA

This gives the output of 1.66 which is nothing but 10/6, thus considering all the 6 cells.

LInux Commands Quiz

copy string in kernel using kstrcpy

Creating copy of existing strings would require allocation of new memory and then assign the old string to new one. The multiple steps required to create a string copy can be done with the help of a single function in the kernel.

char kstrdup (const char * s,gfp_t gfp); Where : const char * s: the string to duplicate gfp_t gfp: the GFP mask used in the kmalloc call when allocating memory

Ref: Kernel API

In the example below, we have created a proc entry to show the usage of the function. A call to read the proc entry creates a copy of the existing string in temp allcates it to the string called copy which we send as output of the proc entry.



Save the file as proc_read_copy.c and compile it using the following makefile.

ifneq ($(KERNELRELEASE),) obj-m := proc_read_copy.o else KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules clean: $(MAKE) -C $(KERNELDIR) M=$(PWD) clean endif

Compile and load the module into kernel using.

$ make $ sudo insmod proc_read_copy.ko

To see the output, read the proc entry created by the module.

$cat /proc/copy hello

Example of using getnstimeofday in linux kernel

The linux kernel provides a number of interfaces to manage time. getnstimeofday is one of them, which gives the time in seconds and nanoseconds . The function is implemented in "timekeeping32.h" and returns a structure of the type timespec which has two members.

struct timespec64 { time64_t tv_sec; /* seconds */ long tv_nsec; /* nanoseconds */ };

To print the time, we only need to print the values of tv_sec and tv_nsec which gets filled by the call to the function getnstimeofday.

In the following example code, we have created a proc entry called gettime, which prints out the values of seconds and nanoseconds when read.



Save the above code as proc_read_gettimeofday.c and compile the code using the following makefile.

ifneq ($(KERNELRELEASE),) obj-m := proc_read_gettimeofday.o else KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules clean: $(MAKE) -C $(KERNELDIR) M=$(PWD) clean endif

Compile and insert the module using

$ make $ sudo insmod proc_read_getnstimeofday.ko

To see the output, just read the proc entry gettime, using the cat command.

cat /proc/gettime 1584690328 seconds 290430470 nanoseconds

Using get_options to read a range of integer arguments from a function in linux kernel.

In the post , we saw how to use read integers using the get_option, if we want to read a range of integers we can use get_options.

char * get_options (const char * str,int nints, int * ints); Where : const char * str: String to be parsed int nints: size of integer array int * ints:integer array

Ref: Kernel API

To read the numbers that are passed,as it is a range we will use an array into which the numbers can be filled. The array will have to be declared with the appropriate size.

The array will be passed to get_options which will fill the array with the elements that belong the range that was passed as shown in the function below.

static __init int getargs(char *str){ char *ret; int i=0,num; int pint[5]; ret=get_options(str,ARRAY_SIZE(pint),pint); for(i=0;i<ARRAY_SIZE(pint);i++) printk(KERN_INFO "%d\n",pint[i]); return 0; }

We can pass a range of integers seperated by a "-" , which will be used to fill the array with the elements.

The following is the full code that passes range of numbers to the getargs function shown above,which in turn prints out all the numbers in the range.



Save the file as readOptions.c and compile it using the following makefile.

ifneq ($(KERNELRELEASE),) obj-m := readOptions.o else KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules clean: $(MAKE) -C $(KERNELDIR) M=$(PWD) clean endif

Compile and insert the code using

$ make $ sudo insmod readOptions.ko

To view the output, run the command dmesg.

$ dmesg [70181.880599] 1 [70181.880601] 2 [70181.880602] 3 [70181.880603] 4

Parsing integer argument to functions in linux kernel

Kernel API provides functions to help making parsing of integer arguments being passed to functions easier. One of the functions is

int get_option (char ** str,int * pint); where char ** str option string int * pint (output) integer value parsed from str

Ref: Kernel API

To understand what has been passed as the argument we need to look at the return value of the function. 0 - no int in string 1 - int found, no subsequent comma 2 - int found including a subsequent comma 3 - hyphen found to denote a range

To understand the working a function is implemented as an example which tests for all the 4 possible return values and prints the option received.

static __init int getargs(char *str){ int ret; ret=get_option(&str,&pint); if(ret==0) printk(KERN_INFO "no arguments passed\n\n"); else if(ret==1) printk(KERN_INFO "Found the argument %d\n\n",pint); else if(ret==2) printk(KERN_INFO "Found the argument %d with ,\n\n",pint); else if(ret==3){ printk(KERN_INFO"Found range %d%s\n\n",pint,str); }

In the function above the argument is received in *str, which is passed to the get_option function which, which in turn assigns the values to pint from the str.

To see the function in action, we can call the function in the init function with different arguments as shown in the example below.



In the code, we have called the function "getargs" with no arguments,one argument,argument and a comma and specified a range.

To compile code,save it as readOptions.c use the following makefile

ifneq ($(KERNELRELEASE),) obj-m := readOptions.o else KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules clean: $(MAKE) -C $(KERNELDIR) M=$(PWD) clean endif

To comple and insert the code.

$ make $ /sbin/insmod readOptions.ko

To see the output run the command dmesg

$dmesg [56350.625181] no arguments passed [56350.625188] Found the argument 10 [56350.625191] Found the argument 20 with , [56350.625193] Found range 30-40

In the above output we can see that, the first call to getargs did not have any arguments in it, hence we see the output as no arguments. The calls after that print out exactly as they are passed.

Creating a FIFO in linux kernel

FIFO is a first in first out data structure that which can be used to hold any kind of data. Linux kernel provides useful APIs to make creation and use of FIFO data structure easy.

The first step in creation of FIFO is to define the FIFO required with the type of data it will be holding using

DEFINE_KFIFO ( fifo,type,size); Where fifo : Name of the fifo to be created type: The datatype of the data to be stored in the fifo. size : The number of elements that the FIFO can hold, it can only be a power of 2.

Once the FIFO has been defined we can use a number of functions available to add,remove, check the FIFO. To put data into the FIFO

kfifo_put (fifo,val); fifo: The fifo to which data needs to be added. val: The data that has to be added to the fifo.

To take the date out of the FIFO

kfifo_get (fifo,val); fifo: The fifo from which data needs to be removed val: The address where the data removed from the FIFO will be stored.

Just to see the above functions in use we will create a proc entry which will output one data from a FIFO that gets created as soon as the module is inserted into the kernel.

To create a module with 6 char entries

#define FIFO_SIZE 6 DEFINE_KFIFO(test,char,FIFO_SIZE);

An array of values to be added to the FIFO

char entries[]={'a','b','c','d','e','f','g','h'};

To add the entries into the FIFO when the module gets inserted into the kernel, the init function needs to call the kfifo_put function

int proc_init (void) { int i=0; create_new_proc_entry(); for(i=0;i<6;i++) kfifo_put(&test,entries[i]); return 0; }

Once the fifo has been created, we can extract one data at a time using the function kfifo_get . To ensure that only one data is read from the FIFO each time we use the cat command on the proc entry extra checks and flags are needed

ssize_t read_proc(struct file *filp,char *buf,size_t count,loff_t *offp ) { int ret,size; char *temp,ch; if(flag==0) { size=0; flag=1; printk(KERN_INFO "in if"); } else { if(kfifo_is_empty(&test)) { temp="FIFO empty"; printk(KERN_INFO "in empty"); size=strlen(temp); simple_read_from_buffer(buf,count,offp,temp,size); } else { ret=kfifo_get(&test,&ch); size=ret; simple_read_from_buffer(buf,count,offp,&ch,size); } flag=flag-1; } if(flag==0) { size=0; flag=1; printk(KERN_INFO "in if"); } else { if(kfifo_is_empty(&test)) { temp="FIFO empty"; size=strlen(temp); simple_read_from_buffer(buf,count,offp,temp,size); } else { ret=kfifo_get(&test,&ch); size=ret; printk(KERN_INFO "in else %d",ret); simple_read_from_buffer(buf,count,offp,&ch,ret); } flag=flag-1; } return size; }

The function kfifo_is_empty returns true when the fifo is empty else it returns false.

The full code for creation of the proc entry called "fifo" which will output one data value at a time is:



If the file is saved as proc_read_fifo.c, it can be compiled using



To test the code, once the compile and insert the code

$ make $ sudo insmod proc_read_fifo.ko

Read the proc entry using the cat command $ cat /proc/fifo a $ cat /proc/fifo b $ cat /proc/fifo c $ cat /proc/fifo d $ cat /proc/fifo e $ cat /proc/fifo f $ cat /proc/fifo FIFO empty

The output shows that every call to read the entry removes one item from the fifo and when all entries are removed "FIFO empty" message gets printed.

Using sched_clock to get kernel uptime

In this post we will see how we can get the information of number of nanoseconds the kernel has been working from and how to print it. We will create a proc entry which when read will print the number of nano seconds from which the kernel has been up for.

The function that is available in kernel to get information about the kernel uptime in nano seconds is sched_clock. sched_clock for x86 is defined as a function in the file "arch/x86/tsc.c", which basically overwrites a default version of the function.

According to the linux documentation : "This function shall return the number of nanoseconds since the system was started. An architecture may or may not provide an implementation of sched_clock() on its own. If a local implementation is not provided, the system jiffy counter will be used as sched_clock()."

To use the function in a module we will need the header file "linux/sched/clock.h"

The function is called with no arguments and returns a "unsigned long long".

In the code below a proc entry is created that will print out the output of sched_clock by converting it to the string.

u64 time=sched_clock(); char *temp; temp=kmalloc(50*sizeof(char),GFP_KERNEL); sprintf(temp,"%lld",time); len=strlen(temp); size=sizeof(char)*len;

The details of proc entry and its creation have been discussed in the posts
Creating read only proc entry in linux 5.3

Creating proc read write function in linux kernel 5.3

. The following is the full code for creating the proc entry to display the system up time in nanoseconds



Assuming the above file is saved as "proc_read_time.c". Here is the makefile that can be used to compile the code.

ifneq ($(KERNELRELEASE),) obj-m := proc_read_time.o else KERNELDIR ?= /lib/modules/$(shell uname -r)/build PWD := $(shell pwd) default: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules clean: $(MAKE) -C $(KERNELDIR) M=$(PWD) clean endif

Once the code gets compiled successfully, insert the module using $sudo insmod proc_read_time.ko

To test the code , read the proce entry that was created using the cat command $ cat /proc/time 15289174913271

The number shown is the number of nano seconds from which the kernel has been running.