Add RCU locking while iterating over task structs; thanks to @iwoeruhsdfwoi

kaiwan · kaiwan · commit 2d235639c41e · 2022-02-11T09:47:38.000+05:30
PacktPublishing#11
diff --git a/ch6/foreach/prcs_showall/prcs_showall.c b/ch6/foreach/prcs_showall/prcs_showall.c
@@ -48,6 +48,21 @@ static int show_prcs_in_tasklist(void)
 	char hdr[] = "     Name       |  TGID  |   PID  |  RUID |  EUID";
 
 	pr_info("%s\n", &hdr[0]);
+	/*
+	 * The for_each_process() is a macro that iterates over the task structures in memory.
+	 * The task structs are global of course; this implies we should hold a lock of some
+	 * sort while working on them (even if only reading!). So, doing
+	 *  read_lock(&tasklist_lock);
+	 *  [...]
+	 *  read_unlock(&tasklist_lock);
+	 * BUT, this lock - tasklist_lock - isn't exported and thus unavailable to modules.
+	 * So, using an RCU read lock is indicated here (this has been added later to this code).
+	 * FYI: a) Ch 12 and Ch 13 cover the details on kernel synchronization.
+	 *      b) Read Copy Update (RCU) is a complex synchronization mechanism; it's
+	 * conceptually explained really well within this blog article:
+	 *  https://reberhardt.com/blog/2020/11/18/my-first-kernel-module.html
+	 */
+	rcu_read_lock();
 	for_each_process(p) {
 		memset(tmp, 0, 128);
 		n = snprintf(tmp, 128, "%-16s|%8d|%8d|%7u|%7u\n", p->comm, p->tgid, p->pid,
@@ -64,6 +79,7 @@ static int show_prcs_in_tasklist(void)
 		cond_resched();
 		total++;
 	}			// for_each_process()
+	rcu_read_unlock();
 
 	return total;
 }
diff --git a/ch6/foreach/thrd_showall/thrd_showall.c b/ch6/foreach/thrd_showall/thrd_showall.c
@@ -62,15 +62,25 @@ static int showthrds(void)
 "------------------------------------------------------------------------------------------\n";
 
 	pr_info("%s", hdr);
-#if 0
-	/* the tasklist_lock reader-writer spinlock for the task list 'should'
-	 * be used here, but, it's not exported, hence unavailable to our kernel module
-	 */
-	read_lock(&tasklist_lock);
-#endif
-
+		pr_info("%s\n", &hdr[0]);
 	disp_idle_thread();
 
+	/*
+	 * The do_each_thread() / while_each_thread() is a pair of macros that iterates over
+	 * _all_ task structures in memory.
+	 * The task structs are global of course; this implies we should hold a lock of some
+	 * sort while working on them (even if only reading!). So, doing
+	 *  read_lock(&tasklist_lock);
+	 *  [...]
+	 *  read_unlock(&tasklist_lock);
+	 * BUT, this lock - tasklist_lock - isn't exported and thus unavailable to modules.
+	 * So, using an RCU read lock is indicated here (this has been added later to this code).
+	 * FYI: a) Ch 12 and Ch 13 cover the details on kernel synchronization.
+	 *      b) Read Copy Update (RCU) is a complex synchronization mechanism; it's
+	 * conceptually explained really well within this blog article:
+	 *  https://reberhardt.com/blog/2020/11/18/my-first-kernel-module.html
+	 */
+	rcu_read_lock();
 	do_each_thread(g, t) {     /* 'g' : process ptr; 't': thread ptr */
 		task_lock(t);
 
@@ -121,10 +131,8 @@ static int showthrds(void)
 		memset(tmp, 0, sizeof(tmp));
 		task_unlock(t);
 	} while_each_thread(g, t);
-#if 0
-	/* <same as above, reg the reader-writer spinlock for the task list> */
-	read_unlock(&tasklist_lock);
-#endif
+	rcu_read_unlock();
+
 	return total;
 }
 
