Documentation/trace/ring-buffer-design.rst

28 	- the task that writes into the ring buffer (same as writer)
30 writer
81 but a writer may interrupt another writer, but it must finish writing
82 before the previous writer may continue. This is very important to the
94 This is very much like a writer being preempted by an interrupt and
99 cannot preempt/interrupt a writer, but it may read/consume from the
100 buffer at the same time as a writer is writing, but the reader must be
102 and can be preempted by a writer.
104 A writer can preempt a reader, but a reader cannot preempt a writer.
106 as a writer.
129 it wants with it, as long as a writer has left that page.
212 When the writer leaves the page, it simply goes into the ring buffer
233 The commit page only is updated by the outermost writer in the
234 writer stack. A writer that preempts another writer will not move the
238 in the ring buffer and passed back to the writer. When the writer
251       +---------+  <--- given back to writer (current commit)
276       +---------+  <--- given back to second writer
280   After second writer commits::
293   When the first writer commits::
438 	- the page being pointed to is being updated by a writer
597 writer may move the tail page. The way this is done is that the writer
601 move the head page, until the writer is finished with the move.
603 This eliminates any races that the reader can have on the writer. The reader
604 must spin, and this is why the reader cannot preempt the writer::
691 by the outermost writer (the writer that was preempted).
692 This means that the commit will not move while a writer is moving the
732                       tail page (moved by nested writer)
742 been moved forward, the writer will just try again to reserve storage
765 But if a nested writer preempts here, it will see that the next
771 The nested writer will set the new head page pointer::
781 But it will not reset the update back to normal. Only the writer
793 After the nested writer finishes, the outermost writer will convert
810   (first writer)
830 Next writer comes in, and sees the update and sets up the new
833   (second writer)
843 The nested writer moves the tail page forward. But does not set the old
844 update page to NORMAL because it is not the outermost writer::
854 Another writer preempts and sees the page after the tail page is a head page.
857   (third writer)
867 The writer will move the head page forward::
870   (third writer)
880 But now that the third writer did change the HEAD flag to UPDATE it
884   (third writer)
895 Then it will move the tail page, and return back to the second writer::
898   (second writer)
909 The second writer will fail to move the tail page because it was already
911 It will return to the first writer::
914   (first writer)
924 The first writer cannot know atomically if the tail page moved
929   (first writer)
939 Since the cmpxchg returns the old value of the pointer the first writer
945   (first writer)
960   (first writer)
970 Now the writer can update the head page. This is also why the head page must
971 remain in UPDATE and only reset by the outermost writer. This prevents
975   (first writer)