[Linux-kernel-mentees] [PATCH] Documentation: RCU: Convert RCU array to reST

Didik Setiawan ds at didiksetiawan.com
Thu Oct 10 06:31:58 UTC 2019

RCU array reST markup.

Signed-off-by: Didik Setiawan <ds at didiksetiawan.com>
 .../RCU/{arrayRCU.txt => arrayRCU.rst}        | 20 +++++++++++--------
 Documentation/RCU/index.rst                   |  1 +
 2 files changed, 13 insertions(+), 8 deletions(-)
 rename Documentation/RCU/{arrayRCU.txt => arrayRCU.rst} (92%)

diff --git a/Documentation/RCU/arrayRCU.txt b/Documentation/RCU/arrayRCU.rst
similarity index 92%
rename from Documentation/RCU/arrayRCU.txt
rename to Documentation/RCU/arrayRCU.rst
index f05a9afb2c39..6e0cb6d5c1f2 100644
--- a/Documentation/RCU/arrayRCU.txt
+++ b/Documentation/RCU/arrayRCU.rst
@@ -1,5 +1,7 @@
-Using RCU to Protect Read-Mostly Arrays
+.. _array_rcu_doc:
+Using RCU to Protect Read-Mostly Arrays
 Although RCU is more commonly used to protect linked lists, it can
 also be used to protect arrays.  Three situations are as follows:
@@ -24,16 +26,16 @@ to be safely used.
 That aside, each of the three RCU-protected pointer situations are
 described in the following sections.
 Situation 1: Hash Tables
 Hash tables are often implemented as an array, where each array entry
 has a linked-list hash chain.  Each hash chain can be protected by RCU
 as described in the listRCU.txt document.  This approach also applies
 to other array-of-list situations, such as radix trees.
 Situation 2: Static Arrays
 Static arrays, where the data (rather than a pointer to the data) is
 located in each array element, and where the array is never resized,
@@ -41,11 +43,13 @@ have not been used with RCU.  Rik van Riel recommends using seqlock in
 this situation, which would also have minimal read-side overhead as long
 as updates are rare.
-Quick Quiz:  Why is it so important that updates be rare when
-	     using seqlock?
+Quick Quiz:
+        Why is it so important that updates be rare when using seqlock?
+:ref:`Answer to Quick Quiz <answer_quick_quiz_array>`
 Situation 3: Resizeable Arrays
 Use of RCU for resizeable arrays is demonstrated by the grow_ary()
 function formerly used by the System V IPC code.  The array is used
@@ -60,7 +64,7 @@ the remainder of the new, updates the ids->entries pointer to point to
 the new array, and invokes ipc_rcu_putref() to free up the old array.
 Note that rcu_assign_pointer() is used to update the ids->entries pointer,
 which includes any memory barriers required on whatever architecture
-you are running on.
+you are running on. ::
 	static int grow_ary(struct ipc_ids* ids, int newsize)
@@ -112,7 +116,7 @@ a simple check suffices.  The pointer to the structure corresponding
 to the desired IPC object is placed in "out", with NULL indicating
 a non-existent entry.  After acquiring "out->lock", the "out->deleted"
 flag indicates whether the IPC object is in the process of being
-deleted, and, if not, the pointer is returned.
+deleted, and, if not, the pointer is returned. ::
 	struct kern_ipc_perm* ipc_lock(struct ipc_ids* ids, int id)
@@ -144,9 +148,9 @@ deleted, and, if not, the pointer is returned.
 		return out;
+.. _answer_quick_quiz_array:
 Answer to Quick Quiz:
 	The reason that it is important that updates be rare when
 	using seqlock is that frequent updates can livelock readers.
 	One way to avoid this problem is to assign a seqlock for
diff --git a/Documentation/RCU/index.rst b/Documentation/RCU/index.rst
index 340a9725676c..75443a0599ed 100644
--- a/Documentation/RCU/index.rst
+++ b/Documentation/RCU/index.rst
@@ -9,6 +9,7 @@ RCU concepts
+   arrayRCU
 .. only:: subproject and html

More information about the Linux-kernel-mentees mailing list