Asynchronous notification mechanism of character device driver

1 The concept of asynchronous notification is introduced

Review the previous three key reading methods

• A query ： Extreme consumption of resources ,
• Interrupt mode ：read Will also sleep , It doesn't consume resources , But if no key is pressed, the interrupt does not occur , that read Never return .
• poll Mechanism ： Specify the timeout period , If you haven't pressed the key after the time, you will return to .

The common point of these three methods is that the application actively reads and queries , Is there a way , When a key is pressed , Driver to remind the application , Then the application reads the keys , This method is called asynchronous notification , Use signal signal Realization , Signaling between processes .

2 Example of signal communication between processes

We used kill -9 PID, In fact, that is kill This process sends 9 Give a process , Next, let's write an example of signal communication , We use it man signal Take a look at the use of signal functions .

First, you need to include signal.h This header file , This signal is similar to our interruption , There is also a number and a handler .

  We compile this application , function , And then use ps Order to have a look , Found that he had been dormant

  Then we send a signal to him ,kill -USR1 833, Then I found that the application printed out the content

  Let's summarize the key points of sending signals

• Register signal processing functions
• Who sends the signal
• To whom is the signal sent
• How to signal

3 Write code

Now our goal is ： When you press the key , Drive notification applications ,

• The signal processing function should be registered in the application
• The driver signals
• To the app , Then the application should tell the driver , Application's PID How much is the , Otherwise I don't know what to send to that application
• How to send ,kill_fasync

We don't know kill_fasync How to use it? , Let's see how others use it , Let's search the kernel code , Then copy it to the interrupt service program of the key , We signal in the interrupt service program ,

  And then we make changes , Let's see rtc_asynv_queue How to define it , Then define a ,

To whom , It should be in the structure button_async It defines who to send it to , So let's see how to initialize this structure ,  Our search found that it was initialized here ,

  So we are also adding one in our driver structure

 fifth_drv_fasync This function will be used to button_async To initialize , Then, during initialization, there will be an application to be sent to in the structure , So this fifth_drv_fasync When is a function called , Is when our application calls fasync Called on function fifth_drv_fasync, So obviously our application will call fasync To set the structure ,