[Linux kernel] [Linux kernel Programming] Learning notes (ii)

Linux kernel ———— queue

Linux kernel--queue

Defined:

[CPP]View Plaincopy

1. struct __kfifo{
2. unsigned int in; //Queue offset, write index
3. unsigned int out; //Queue offset, read index
4. unsigned int mask;
5. unsigned int esize;
6. void *data;
7. }

Use:

Create a queue that creates and initializes a kfifo of size:

[CPP]View Plaincopy

2. __kfifo_alloc Int (struct __kfifo *fifo, unsigned int size,
4. size_t esize, gfp_t gfp_mask)
6. 40 {
10. Size = roundup_pow_of_two (size);
12. 46
14. fifo->in = 0;
16. fifo->out = 0;
18. Fifo->esize = esize;
20. 50
22. if (Size < 2) {
24. Fifo->data = NULL;
26. Fifo->mask = 0;
28. Return-einval;
30. 55}
32. 56
34. Fifo->data = kmalloc (Size * esize, gfp_mask);
36. 58
38. if (!fifo->data) {
40. Fifo->mask = 0;
42. Return-enomem;
44. 62}
46. Fifo->mask = size-1;
48. 64
50. 0;
52. 66}

Determines whether an integer is a power of 2 for the whole number of times

[CPP]View Plaincopy

1. static inline int is_power_of_2 (unsigned long long N)
2. {
3. Return (n!=0 && (n& (n-1) ==0))
4. }

The method to push data into the queue is the kfifo_in () function

[CPP]View Plaincopy

2. 102 static void kfifo_copy_in (struct __KFIFO *fifo, const void *src,
4. 103 unsigned int len, unsigned int off)
6. 104 {
8. unsigned int size = fifo->mask + 1;
10. 106 unsigned int esize = fifo->esize;
12. 107 unsigned int l;
14. 108
16. 109 Off &= fifo->mask; //The operation will be mathematically based on the modulus of length fifo->mask
18. if (esize! = 1) {
20. 111 off *= Esize;
22. The size of *= esize;
24. 113 Len *= esize;
26. 114}
28. L = min (len, size-off); the meaning of the//size-off represents the size of the current in to the end of the buffer,
30. * /
32. Copies the L bytes from buffer to the remaining space of the buffers, L<=len, and <= the space from real_in to the end of the buffer.
34. So this copy may not have been copied, but it will not cause the buffer to cross out
36. */
38. 117 memcpy (Fifo->data + off, SRC, l);
40. /* 
42. Len > L, copy the remaining contents of buffer, in fact the address is buffer + L, and the remaining size is Len-l
44. When len = = L, the following memcpy do nothing.
46. */
48. 118 memcpy (Fifo->data, src + L, len-l);
50. 123 SMP_WMB ();
52. 124}
54. 125
56. 126 unsigned int __kfifo_in (struct __kfifo *fifo,
58. 127 const void *buf, unsigned int len)//buf points to the buffer in which the request was queued, Len represents the size of the requested write /c2>
60. 128 {
62. 129 unsigned int l;
64. 131 L = kfifo_unused (FIFO); //Calculate the size of the remaining space in the queue, fifo->size-(fifo->in-fifo->out)
66. if (len > L)
68. 133 len = l;
70. 135 kfifo_copy_in (FIFO, buf, Len, fifo->in);
72. 136 Fifo->in + = Len;
74. 137 return Len;
76. 138}

The clever thing about Kfifo is that in and out are defined as unsigned types, both in and out are incremented when put and get, and overflow when maximum is reached, so that it is recycled from 0 onwards

[Linux kernel] [Linux kernel Programming] Learning notes (ii)