67  * associated with the CPU it is currently executing on.  A reader may read
70  * The reader is special. For each per cpu buffer, the reader has its own
71  * reader page. When a reader has read the entire reader page, this reader
74  * Now, as long as the writer is off the reader page, the reader can do what
81  *   |reader|          RING BUFFER
92  *   |reader|          RING BUFFER
103  *   |reader|          RING BUFFER
119  *      |  Reader------^               |
124  * After we make this swap, the reader can hand this page off to the splice
908 	/* The reader can read an empty page, but not more than that */  in ring_buffer_nr_dirty_pages()
1231  * The reader page is always off the ring buffer, but when the
1232  * reader finishes with a page, it needs to swap its page with
1233  * a new one from the buffer. The reader needs to take from
1239  * The reader must be careful to replace only the head page, and
1241  * ASCII art, the reader sets its old page to point to the next
1243  * the old reader page. But if the writer moves the head page
1244  * during this operation, the reader could end up with the tail.
1277  *         R      Reader page
1282  *  What the above shows is that the reader just swapped out
1283  *  the reader page with a page in the buffer, but before it
1286  *  the new page added by the reader and is about to move forward
1317  * Because the reader may move the head_page pointer, we can
1319  * the reader page). But if the next page is a header page,
1338  * The unique thing about the reader page, is that, if the
1340  * back to the reader page.
1416 	/* check if the reader took the page */  in rb_head_page_set()
1938 	 * We don't race with the readers since we have acquired the reader  in rb_remove_pages()
1949 	 * tail page might be on reader page, we remove the next page  in rb_remove_pages()
2043 	 * We are holding the reader lock, so the reader page won't be swapped  in rb_insert_pages()
2046 	 * We are going to adapt the reader page update process where:  in rb_insert_pages()
2175 		 * Don't succeed if resizing is disabled, as a reader might be  in ring_buffer_resize()
2261 		 * Don't succeed if resizing is disabled, as a reader might be  in ring_buffer_resize()
2462 	 * The iterator could be on the reader page (it starts there).  in rb_inc_iter()
2463 	 * But the head could have moved, since the reader was  in rb_inc_iter()
2510 	 *  MOVED  - a reader on another CPU moved the next  in rb_handle_head_page()
2511 	 *           pointer to its reader page. Give up  in rb_handle_head_page()
2549 		 * The reader is on another CPU and just did  in rb_handle_head_page()
2561 	 * set to UPDATE. This will keep the reader from  in rb_handle_head_page()
2562 	 * swapping the head page with the reader page.  in rb_handle_head_page()
2563 	 * The reader (on another CPU) will spin till  in rb_handle_head_page()
2655 		 * and the reader will ignore it.  in rb_reset_tail()
2668 	 * This will be used by the reader to add lost event  in rb_reset_tail()
2748 	 * We are fighting against races between a reader that  in rb_move_tail()
2749 	 * could be on another CPU trying to swap its reader  in rb_move_tail()
2757 	 * reader page.  in rb_move_tail()
2762 		 * If the commit is not on the reader page, then  in rb_move_tail()
2785 			 * commit page could still be on the reader  in rb_move_tail()
3859 	 * Because the commit page may be on the reader page we  in rb_decrement_entry()
3998 	struct buffer_page *reader = cpu_buffer->reader_page;  in rb_per_cpu_empty()  local
4006 	/* Reader should exhaust content in reader page */  in rb_per_cpu_empty()
4007 	if (reader->read != rb_page_commit(reader))  in rb_per_cpu_empty()
4011 	 * If writers are committing on the reader page, knowing all  in rb_per_cpu_empty()
4014 	if (commit == reader)  in rb_per_cpu_empty()
4018 	 * If writers are committing on a page other than reader page  in rb_per_cpu_empty()
4026 	 * to care about there're committed data, and the reader will  in rb_per_cpu_empty()
4027 	 * swap reader page with head page when it is to read data.  in rb_per_cpu_empty()
4206 	 * if the tail is on reader_page, oldest time stamp is on the reader  in ring_buffer_oldest_event_ts()
4441 	struct buffer_page *reader;  in ring_buffer_iter_empty()  local
4450 	reader = cpu_buffer->reader_page;  in ring_buffer_iter_empty()
4476 		(iter->head_page == reader && commit_page == head_page &&  in ring_buffer_iter_empty()
4545 	struct buffer_page *reader = NULL;  in rb_get_reader_page()  local
4557 	 * start of the reader inserts an empty page, it causes  in rb_get_reader_page()
4562 		reader = NULL;  in rb_get_reader_page()
4566 	reader = cpu_buffer->reader_page;  in rb_get_reader_page()
4569 	if (cpu_buffer->reader_page->read < rb_page_size(reader))  in rb_get_reader_page()
4574 		       cpu_buffer->reader_page->read > rb_page_size(reader)))  in rb_get_reader_page()
4578 	reader = NULL;  in rb_get_reader_page()
4587 	 * Reset the reader page to size zero.  in rb_get_reader_page()
4596 	 * Splice the empty reader page into the list around the head.  in rb_get_reader_page()
4598 	reader = rb_set_head_page(cpu_buffer);  in rb_get_reader_page()
4599 	if (!reader)  in rb_get_reader_page()
4601 	cpu_buffer->reader_page->list.next = rb_list_head(reader->list.next);  in rb_get_reader_page()
4602 	cpu_buffer->reader_page->list.prev = reader->list.prev;  in rb_get_reader_page()
4609 	cpu_buffer->pages = reader->list.prev;  in rb_get_reader_page()
4611 	/* The reader page will be pointing to the new head */  in rb_get_reader_page()
4618 	 * side. Note, the reader will constantly fail the swap  in rb_get_reader_page()
4637 	ret = rb_head_page_replace(reader, cpu_buffer->reader_page);  in rb_get_reader_page()
4648 	 * Now make the new head point back to the reader page.  in rb_get_reader_page()
4650 	rb_list_head(reader->list.next)->prev = &cpu_buffer->reader_page->list;  in rb_get_reader_page()
4655 	/* Finally update the reader page to the new head */  in rb_get_reader_page()
4656 	cpu_buffer->reader_page = reader;  in rb_get_reader_page()
4668 	if (reader && reader->read == 0)  in rb_get_reader_page()
4669 		cpu_buffer->read_stamp = reader->page->time_stamp;  in rb_get_reader_page()
4681 		if (likely(!reader || rb_page_write(reader) <= BUF_PAGE_SIZE))  in rb_get_reader_page()
4686 		/* Get the latest version of the reader write value */  in rb_get_reader_page()
4692 		reader = NULL;  in rb_get_reader_page()
4698 	 * In addition, a writer may be writing on the reader page  in rb_get_reader_page()
4706 	return reader;  in rb_get_reader_page()
4712 	struct buffer_page *reader;  in rb_advance_reader()  local
4715 	reader = rb_get_reader_page(cpu_buffer);  in rb_advance_reader()
4718 	if (RB_WARN_ON(cpu_buffer, !reader))  in rb_advance_reader()
4772 	struct buffer_page *reader;  in rb_buffer_peek()  local
4787 	reader = rb_get_reader_page(cpu_buffer);  in rb_buffer_peek()
4788 	if (!reader)  in rb_buffer_peek()
4815 			*ts = rb_fix_abs_ts(*ts, reader->page->time_stamp);  in rb_buffer_peek()
5695  * the writer is off the reader page.
5712 	struct buffer_page *reader;  in ring_buffer_read_page()  local
5741 	reader = rb_get_reader_page(cpu_buffer);  in ring_buffer_read_page()
5742 	if (!reader)  in ring_buffer_read_page()
5747 	read = reader->read;  in ring_buffer_read_page()
5748 	commit = rb_page_commit(reader);  in ring_buffer_read_page()
5771 		 * the reader page.  in ring_buffer_read_page()
5804 			rpos = reader->read;  in ring_buffer_read_page()
5823 		cpu_buffer->read += rb_page_entries(reader);  in ring_buffer_read_page()
5824 		cpu_buffer->read_bytes += rb_page_commit(reader);  in ring_buffer_read_page()
5828 		bpage = reader->page;  in ring_buffer_read_page()
5829 		reader->page = *data_page;  in ring_buffer_read_page()
5830 		local_set(&reader->write, 0);  in ring_buffer_read_page()
5831 		local_set(&reader->entries, 0);  in ring_buffer_read_page()
5832 		reader->read = 0;  in ring_buffer_read_page()
5840 		if (reader->real_end)  in ring_buffer_read_page()
5841 			local_set(&bpage->commit, reader->real_end);  in ring_buffer_read_page()