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
910 	/* The reader can read an empty page, but not more than that */  in ring_buffer_nr_dirty_pages()
1229  * The reader page is always off the ring buffer, but when the
1230  * reader finishes with a page, it needs to swap its page with
1231  * a new one from the buffer. The reader needs to take from
1237  * The reader must be careful to replace only the head page, and
1239  * ASCII art, the reader sets its old page to point to the next
1241  * the old reader page. But if the writer moves the head page
1242  * during this operation, the reader could end up with the tail.
1275  *         R      Reader page
1280  *  What the above shows is that the reader just swapped out
1281  *  the reader page with a page in the buffer, but before it
1284  *  the new page added by the reader and is about to move forward
1315  * Because the reader may move the head_page pointer, we can
1317  * the reader page). But if the next page is a header page,
1336  * The unique thing about the reader page, is that, if the
1338  * back to the reader page.
1414 	/* check if the reader took the page */  in rb_head_page_set()
1962 	 * We don't race with the readers since we have acquired the reader  in rb_remove_pages()
1973 	 * tail page might be on reader page, we remove the next page  in rb_remove_pages()
2068 	 * We are holding the reader lock, so the reader page won't be swapped  in rb_insert_pages()
2071 	 * We are going to adapt the reader page update process where:  in rb_insert_pages()
2199 		 * Don't succeed if resizing is disabled, as a reader might be  in ring_buffer_resize()
2275 		 * Don't succeed if resizing is disabled, as a reader might be  in ring_buffer_resize()
2466 	 * The iterator could be on the reader page (it starts there).  in rb_inc_iter()
2467 	 * But the head could have moved, since the reader was  in rb_inc_iter()
2514 	 *  MOVED  - a reader on another CPU moved the next  in rb_handle_head_page()
2515 	 *           pointer to its reader page. Give up  in rb_handle_head_page()
2553 		 * The reader is on another CPU and just did  in rb_handle_head_page()
2565 	 * set to UPDATE. This will keep the reader from  in rb_handle_head_page()
2566 	 * swapping the head page with the reader page.  in rb_handle_head_page()
2567 	 * The reader (on another CPU) will spin till  in rb_handle_head_page()
2659 		 * and the reader will ignore it.  in rb_reset_tail()
2675 	 * This will be used by the reader to add lost event  in rb_reset_tail()
2751 	 * We are fighting against races between a reader that  in rb_move_tail()
2752 	 * could be on another CPU trying to swap its reader  in rb_move_tail()
2760 	 * reader page.  in rb_move_tail()
2765 		 * If the commit is not on the reader page, then  in rb_move_tail()
2788 			 * 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()
4440 	struct buffer_page *reader;  in ring_buffer_iter_empty()  local
4449 	reader = cpu_buffer->reader_page;  in ring_buffer_iter_empty()
4475 		(iter->head_page == reader && commit_page == head_page &&  in ring_buffer_iter_empty()
4546 	struct buffer_page *reader = NULL;  in rb_get_reader_page()  local
4558 	 * start of the reader inserts an empty page, it causes  in rb_get_reader_page()
4563 		reader = NULL;  in rb_get_reader_page()
4567 	reader = cpu_buffer->reader_page;  in rb_get_reader_page()
4570 	if (cpu_buffer->reader_page->read < rb_page_size(reader))  in rb_get_reader_page()
4575 		       cpu_buffer->reader_page->read > rb_page_size(reader)))  in rb_get_reader_page()
4579 	reader = NULL;  in rb_get_reader_page()
4588 	 * Reset the reader page to size zero.  in rb_get_reader_page()
4597 	 * Splice the empty reader page into the list around the head.  in rb_get_reader_page()
4599 	reader = rb_set_head_page(cpu_buffer);  in rb_get_reader_page()
4600 	if (!reader)  in rb_get_reader_page()
4602 	cpu_buffer->reader_page->list.next = rb_list_head(reader->list.next);  in rb_get_reader_page()
4603 	cpu_buffer->reader_page->list.prev = reader->list.prev;  in rb_get_reader_page()
4610 	cpu_buffer->pages = reader->list.prev;  in rb_get_reader_page()
4612 	/* The reader page will be pointing to the new head */  in rb_get_reader_page()
4619 	 * side. Note, the reader will constantly fail the swap  in rb_get_reader_page()
4638 	ret = rb_head_page_replace(reader, cpu_buffer->reader_page);  in rb_get_reader_page()
4649 	 * Now make the new head point back to the reader page.  in rb_get_reader_page()
4651 	rb_list_head(reader->list.next)->prev = &cpu_buffer->reader_page->list;  in rb_get_reader_page()
4656 	/* Finally update the reader page to the new head */  in rb_get_reader_page()
4657 	cpu_buffer->reader_page = reader;  in rb_get_reader_page()
4669 	if (reader && reader->read == 0)  in rb_get_reader_page()
4670 		cpu_buffer->read_stamp = reader->page->time_stamp;  in rb_get_reader_page()
4682 		if (likely(!reader || rb_page_write(reader) <= BUF_PAGE_SIZE))  in rb_get_reader_page()
4687 		/* Get the latest version of the reader write value */  in rb_get_reader_page()
4693 		reader = NULL;  in rb_get_reader_page()
4702 	return reader;  in rb_get_reader_page()
4708 	struct buffer_page *reader;  in rb_advance_reader()  local
4711 	reader = rb_get_reader_page(cpu_buffer);  in rb_advance_reader()
4714 	if (RB_WARN_ON(cpu_buffer, !reader))  in rb_advance_reader()
4767 	struct buffer_page *reader;  in rb_buffer_peek()  local
4782 	reader = rb_get_reader_page(cpu_buffer);  in rb_buffer_peek()
4783 	if (!reader)  in rb_buffer_peek()
4810 			*ts = rb_fix_abs_ts(*ts, reader->page->time_stamp);  in rb_buffer_peek()
5660  * the writer is off the reader page.
5677 	struct buffer_page *reader;  in ring_buffer_read_page()  local
5706 	reader = rb_get_reader_page(cpu_buffer);  in ring_buffer_read_page()
5707 	if (!reader)  in ring_buffer_read_page()
5712 	read = reader->read;  in ring_buffer_read_page()
5713 	commit = rb_page_commit(reader);  in ring_buffer_read_page()
5736 		 * the reader page.  in ring_buffer_read_page()
5769 			rpos = reader->read;  in ring_buffer_read_page()
5788 		cpu_buffer->read += rb_page_entries(reader);  in ring_buffer_read_page()
5793 		bpage = reader->page;  in ring_buffer_read_page()
5794 		reader->page = *data_page;  in ring_buffer_read_page()
5795 		local_set(&reader->write, 0);  in ring_buffer_read_page()
5796 		local_set(&reader->entries, 0);  in ring_buffer_read_page()
5797 		reader->read = 0;  in ring_buffer_read_page()
5805 		if (reader->real_end)  in ring_buffer_read_page()
5806 			local_set(&bpage->commit, reader->real_end);  in ring_buffer_read_page()