blocking non-blocking poll mechanism asynchronous

1 Blocking
Blocking operation: When performing device operations, if resources cannot be obtained, the process will be suspended until the operable conditions are met before the operation is performed.
read()-->HelloRead
How to implement blocking in the driver?You can define a sleep waiting queue
  wait_queue_head_t q;//Define a sleep waiting queue head
    init_waitqueue_head(&q);//Initialize the sleep waiting queue
Use: helloRead:
  wait_event_interruptible(q,con)-->Sleep the process requesting to read data--"The sleep period can be interrupted
  wait_event(q,con)-->The sleep period cannot be interrupted

HelloWrite:-->Wake up the read process to read data after writing data
wake_up_interruptible(&q);-->Wake up the sleep process that can be interrupted
wake_up;
con=1;

  con: The wake-up condition of the sleep process process: 1 wake up 0 sleep
  Note: When the process is running normally, the process is waiting to be run in the running pair column.
When the process sleeps, the process waits in the sleep waiting queue to be woken up to run

2 Non-blocking
Non-blocking operation: It means that when the device operation cannot be performed, it does not sleep or suspend the process, but immediately returns an incorrect value to the requesting process, and the underlying device driver passes the non-stopThe query device operation can be performed until the operation can be performed and a correct result is returned to the requesting process.
read-->non-blocking
application layer: open("dev/haha0",O_RDWR|O_NONBLOCK);

Driver layer: HelloRead()
if (no data can be read in the device)
{
if (the O_NONBLOCK flag is passed in by the application layer)
    {
Return an incorrect value to the application
} }
else
{
Blocking the process;
blocking the process;
blocking the process

g_charcount: Indicates the number of characters actually written to the kernel

3 poll mechanism
io multiplexing--"select poll epoll
HelloPoll(struct file *pFile, struct poll_table_struct *ptable)

Implementation: 1 Put the process of monitoring the file descriptor into the monitoring queue--"poll_wait(pFile,&q,ptable)
ptable: polling table
Add the process currently operating the file to the sleep waiting queue, add the queue to ptable.
2 The system monitors the sleeping process in the monitoring queue. If there is IO data on the file descriptor of the sleeping process, the system will activate the process.
return mask;
mask: a bit mask used to describe whether the operation can be executed immediately without blockingStatus (each BIT bit can be represented by a macro)
POLLIN: data can be read
POLLRDNORM: normal data can be read
POLLOUT: data can be written
POLLERR: specified file descriptioncharacter error

4 Asynchronous IO
Asynchronous IO: The read process goes to the device to read data. If the device has no data to read, then the current process is blocked. If the kernel detects that the device has data to read, it will send a notification signal to the read process.The read process will execute the processing action corresponding to the signal to read the data.
Application:

A (read data process)
1 Register a signal handler function signal(SIGIO,hander);
2 Open the device file fd=open("/dev/haha0",...);
3 3 Set the host of the file descriptor fcntl(fd,F_SETOWN,getpid());
4 Read the flag of the file descriptor int flags=fcntl(fd,F_GETFL);
5 Set the file descriptor flag fcntl(fd,F_SETFL,flags|FASYNC)->Asynchronous notification flag
      while(1);
    hander-->read()
      Note: fcntl: is a system call function, used to set or get a fileDescriptor properties

B (write data process)
1 open("/dev/haha0");
2 write-->helloWrite-->signal to the reading process
3 close

Driver:

1 HelloFasync
1 Define a global asynchronous notification structure--"Associated signal sender and receiver
2 Initialize asynchronous notification structure
fasync_helper(fd,pFile,on,&fasync)
      2 HelloWrite
          kill_fasync(&fasync,SIGIO,POLL_IN);

SIGIO-->fasync-->fd(read)--"getpid()==A