Linux device Driver---Blocking character device driver---o_nonblock---non-blocking flag "turn"

Transferred from: http://blog.csdn.net/yikai2009/article/details/8653697

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

Directory (?) [-]

1. Blocking
1. Blocking operations
2. Non-blocking operation
2. Blocking mode-read-implementation
3. Blocking mode-write-implementation
4. Non-blocking read and write operations
5. Implementation of instance---read blocking
6. Instance---key driver blocking implementation
1. 1 in the Open function to see if it is blocking or non-blocking mode
2. 2 See also in the Read function
3. 3 in the application
1. 1 running in blocking mode
2. 2 run in a non-blocking manner

Blocking:

When designing a simple character driver, you should be aware of an important issue.

What should a device do when it cannot immediately satisfy a user's read and write requests?

For example: No data is readable when calling read, but may be later;

Or a process tries to write data to the device, but the device is temporarily not ready to receive data.

Applications typically do not care about this problem, and the application simply calls read or write and gets the return value.

The driver should (by default) block the process and put it to sleep until the request can be satisfied .

Blocking actions:

When performing a device operation, if a resource is not available, the process is suspended until the operational conditions are met.

The suspended process goes to sleep and is moved from the scheduler's run queue until the waiting condition is met.

Non-blocking operation:

The process cannot perform device operations without suspending, he either abandons, or keeps querying until it can be manipulated.

Blocking mode-read-implementation:

In a blocking driver, read is implemented as follows:

If the process calls read but the device has no data or insufficient data, the process is blocked.

When the new data arrives, the wake-up process is blocked.

Blocking mode-write-implementation: In a blocking driver, the write implementation is as follows: If the process calls write, but the device does not have enough space for it to write data, the process is blocked. The process is awakened when the data in the device is read away and the buffer is partially empty. Non-blocking read and write operations: blocking Modeis a file read and write operation default mode, but application programmers can use the O_NONBLOCK flag to artificially SetRead and write operations as non-blocking mode.           (This flag is defined in < linux/fcntl.h >, specified when the file is opened.) If set the O_NONBLOCK flag, read and write behave differently if the process does not have data ready when the read is called, or if the buffer does not have space when the write is called, the system just simple return to-eagain, while does not block processes. The implementation of the instance---read blocking: using while is because there may be other signals waking up to sleep, and we want to re-detect if there is data through the while ....  Example---key driver blocking implementation: 1, in the open function to see whether the blocking mode or non-blocking mode: The file structure contains the F_FLAGS flag bit, to see whether the blocking mode or non-blocking mode: O_nonblock is non-blocking mode； [CPP]View PlainCopy

2. if (File->f_flags & o_nonblock)/ * Non-blocking operation * /
4. {
6. if (Down_trylock (&button_lock))/ * Cannot get the semaphore, Down_trylock returns a non-0 value immediately * /
8. Return-ebusy;
10. }
12. else/ * Blocking operation * /
14. {
16. / * Get the semaphore * /
18. Down (&button_lock); / * Get no sleep * /
20. }

2, see the same in the Read function: [CPP]View PlainCopy

2. if (File->f_flags & o_nonblock)/ * Non-blocking operation * /
4. {
6. if (!ev_press)/// ev_press is 1 for press, 0 if set, no button pressed, * /
8. Return-eagain; / * Return-eagain Let's do it again * /
10. }
12. else/ * Blocking operation * /
14. {
16. / * If there is no key action, hibernate * /
18. Wait_event_interruptible (BUTTON_WAITQ, ev_press);
20. }

3, in the application: 1, to run in a blocking manner: the background to execute the application, the process is asleep, press the key, immediately print the key number; [CPP]View PlainCopy

2. int main (int argc, char **argv)
4. {
6. unsigned char key_val;
8. int oflags;
12. FD = open ("/dev/buttons", O_RDWR);
14. if (FD < 0)
16. {
18. printf ("can ' t open!\n");
20. return-1;
22. }
26. While (1)
28. {
30. Read (FD, &key_val, 1);
32. printf ("key_val:0x%x\n", key_val);
34. }
38. return 0;
40. }

2, run in a non-blocking manner: when the open driver, the incoming flag o_nonblock non-blocking;Background execution Application: [CPP]View PlainCopy

2. int main (int argc, char **argv)
4. {
6. unsigned char key_val;
8. int ret;
10. int oflags;
14. FD = open ("/dev/buttons", O_RDWR |  O_nonblock);
16. if (FD < 0)
18. {
20. printf ("can ' t open!\n");
22. return-1;
24. }
28. While (1)
30. {
32. ret = Read (FD, &key_val, 1);
34. printf ("key_val:0x%x, ret =%d\n", Key_val, ret);
36. Sleep (5);
38. }
42. return 0;
44. }

non-blocking mode, no keystroke value pressed, the program immediately return;
The read return value is-1;

Linux device Driver---Blocking character device driver---o_nonblock---non-blocking flag "turn"