Skip to contentSkip to conversation

Add debugobjects checking to RCU callbacks

PATCH In review Paul E. McKenney 3 participants 16 messages May 11, 2010 – May 15, 2010

Subsystems (10)
lore
Share & tools
lore
#0 lore raw

cover Add debugobjects checking to RCU callbacks

Hello!

This patchset pulls Mathieu's debugobject-specific commits out of the earlier patchbomb (http://lkml.org/lkml/2010/5/4/298):

1. Add transition-check capability to debugobjects.
2. Add init_rcu_head_on_stack() and destroy_rcu_head_on_stack() APIs.
3. Remove rcu_head initializations from RCU, except for those
for on-stack rcu_head structures, which must use the APIs introduced in #2 above.
4-9. Ditto for powerpc, block, staging, fs, mm, and selinux.
10. Remove the old rcu_head initialization APIs.
11. Add the debugobjects workings to RCU, enabled by
CONFIG_DEBUG_OBJECTS_RCU_HEAD.

These have been reordered and consolidated to reduce inter-commit dependencies.

Thanx, Paul

 b/arch/powerpc/mm/pgtable.c                   |    1 
 b/block/cfq-iosched.c                         |    1 
 b/block/genhd.c                               |    1 
 b/drivers/staging/batman-adv/hard-interface.c |    1 
 b/fs/file.c                                   |    3 
 b/fs/fs-writeback.c                           |   31 +++-
 b/fs/partitions/check.c                       |    1 
 b/include/linux/debugobjects.h                |   11 +
 b/include/linux/init_task.h                   |    1 
 b/include/linux/rcupdate.h                    |    8 +
 b/kernel/rcupdate.c                           |  170 ++++++++++++++++++++++++++
 b/kernel/rcutiny.c                            |    6 
 b/kernel/rcutorture.c                         |    2 
 b/kernel/rcutree.c                            |    4 
 b/kernel/rcutree_plugin.h                     |    2 
 b/lib/Kconfig.debug                           |    6 
 b/lib/debugobjects.c                          |   59 ++++++++-
 b/mm/backing-dev.c                            |    1 
 b/mm/slob.c                                   |    1 
 b/security/selinux/avc.c                      |    1 
 b/security/selinux/netnode.c                  |    2 
 include/linux/rcupdate.h                      |   55 +++++++-
 kernel/rcutiny.c                              |    2 
 kernel/rcutree.c                              |    2 
 24 files changed, 344 insertions(+), 28 deletions(-)
#1 lore raw

RFC PATCH 1/11 Debugobjects transition check

From: Mathieu Desnoyers <[email protected]>

Implement a basic state machine checker in the debugobjects.

This state machine checker detects races and inconsistencies within the "active" life of a debugobject. The checker only keeps track of the current state; all the state machine logic is kept at the object instance level.

The checker works by adding a supplementary "unsigned int astate" field to the debug_obj structure. It keeps track of the current "active state" of the object.

The only constraints that are imposed on the states by the debugobjects system is that:

- activation of an object sets the current active state to 0,
- deactivation of an object expects the current active state to be 0.

For the rest of the states, the state mapping is determined by the specific object instance. Therefore, the logic keeping track of the state machine is within the specialized instance, without any need to know about it at the debugobject level.

The current object active state is changed by calling:

debug_object_active_state(addr, descr, expect, next)

where "expect" is the expected state and "next" is the next state to move to if the expected state is found. A warning is generated if the expected is not found.

---
 include/linux/debugobjects.h |   11 ++++++++
 lib/debugobjects.c           |   59 +++++++++++++++++++++++++++++++++++++++--
 2 files changed, 67 insertions(+), 3 deletions(-)
include/linux/debugobjects.h +11 -0
index 8c243aa..597692f 100644
@@ -20,12 +20,14 @@ struct debug_obj_descr;
  * struct debug_obj - representaion of an tracked object
  * @node:	hlist node to link the object into the tracker list
  * @state:	tracked object state
+ * @astate:	current active state
  * @object:	pointer to the real object
  * @descr:	pointer to an object type specific debug description structure
  */
 struct debug_obj {
 	struct hlist_node	node;
 	enum debug_obj_state	state;
+	unsigned int		astate;
 	void			*object;
 	struct debug_obj_descr	*descr;
 };
@@ -60,6 +62,15 @@ extern void debug_object_deactivate(void *addr, struct debug_obj_descr *descr);
 extern void debug_object_destroy   (void *addr, struct debug_obj_descr *descr);
 extern void debug_object_free      (void *addr, struct debug_obj_descr *descr);
 
+/*
+ * Active state:
+ * - Set at 0 upon initialization.
+ * - Must return to 0 before deactivation.
+ */
+extern void
+debug_object_active_state(void *addr, struct debug_obj_descr *descr,
+			  unsigned int expect, unsigned int next);
+
 extern void debug_objects_early_init(void);
 extern void debug_objects_mem_init(void);
 #else
lib/debugobjects.c +56 -3

83 lines not on this page · raw message

Signature · 1 line
1.7.0.6
#2 lore raw

RFC PATCH 2/11 rcu head introduce rcu head init on stack

In reply to Paul E. McKenney

From: Mathieu Desnoyers <[email protected]>

PEM:
o Would it be possible to make this bisectable as follows?

a. Insert a new patch after current patch 4/6 that
defines destroy_rcu_head_on_stack(), init_rcu_head_on_stack(), and init_rcu_head() with their !CONFIG_DEBUG_OBJECTS_RCU_HEAD definitions.

This patch performs this transition.

---
 include/linux/rcupdate.h |    8 ++++++++
 1 files changed, 8 insertions(+), 0 deletions(-)
include/linux/rcupdate.h +8 -0
index 23be3a7..b653b4a 100644
@@ -79,6 +79,14 @@ extern void rcu_init(void);
        (ptr)->next = NULL; (ptr)->func = NULL; \
 } while (0)
 
+static inline void init_rcu_head_on_stack(struct rcu_head *head)
+{
+}
+
+static inline void destroy_rcu_head_on_stack(struct rcu_head *head)
+{
+}
+
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 
 extern struct lockdep_map rcu_lock_map;
Signature · 1 line
1.7.0.6
#3 lore raw

RFC PATCH 3/11 rcu: remove all rcu head initializations, except on_stack initializations

In reply to Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

---
 include/linux/init_task.h |    1 -
 kernel/rcutiny.c          |    6 ++++++
 kernel/rcutorture.c       |    2 ++
 kernel/rcutree.c          |    4 ++++
 kernel/rcutree_plugin.h   |    2 ++
 5 files changed, 14 insertions(+), 1 deletions(-)
include/linux/init_task.h +0 -1
index b1ed1cd..7996fc2 100644
@@ -49,7 +49,6 @@ extern struct group_info init_groups;
 		{ .first = &init_task.pids[PIDTYPE_PGID].node },	\
 		{ .first = &init_task.pids[PIDTYPE_SID].node },		\
 	},								\
-	.rcu		= RCU_HEAD_INIT,				\
 	.level		= 0,						\
 	.numbers	= { {						\
 		.nr		= 0,					\
kernel/rcutiny.c +6 -0
index b1804ff..38729d3 100644
@@ -245,11 +245,13 @@ void rcu_barrier(void)
 {
 	struct rcu_synchronize rcu;
 
+	init_rcu_head_on_stack(&rcu.head);
 	init_completion(&rcu.completion);
 	/* Will wake me after RCU finished. */
 	call_rcu(&rcu.head, wakeme_after_rcu);
 	/* Wait for it. */
 	wait_for_completion(&rcu.completion);
+	destroy_rcu_head_on_stack(&rcu.head);
 }
 EXPORT_SYMBOL_GPL(rcu_barrier);
 
@@ -257,11 +259,13 @@ void rcu_barrier_bh(void)
 {
 	struct rcu_synchronize rcu;
 
+	init_rcu_head_on_stack(&rcu.head);
 	init_completion(&rcu.completion);
 	/* Will wake me after RCU finished. */
 	call_rcu_bh(&rcu.head, wakeme_after_rcu);
 	/* Wait for it. */
 	wait_for_completion(&rcu.completion);
+	destroy_rcu_head_on_stack(&rcu.head);
 }
 EXPORT_SYMBOL_GPL(rcu_barrier_bh);
 
@@ -269,11 +273,13 @@ void rcu_barrier_sched(void)
 {
 	struct rcu_synchronize rcu;
 
+	init_rcu_head_on_stack(&rcu.head);
 	init_completion(&rcu.completion);
 	/* Will wake me after RCU finished. */
 	call_rcu_sched(&rcu.head, wakeme_after_rcu);
 	/* Wait for it. */
 	wait_for_completion(&rcu.completion);
+	destroy_rcu_head_on_stack(&rcu.head);
 }
 EXPORT_SYMBOL_GPL(rcu_barrier_sched);
 
kernel/rcutorture.c +2 -0
index 58df55b..077defb 100644
@@ -464,9 +464,11 @@ static void rcu_bh_torture_synchronize(void)
 {
 	struct rcu_bh_torture_synchronize rcu;
 
+	init_rcu_head_on_stack(&rcu.head);
 	init_completion(&rcu.completion);
 	call_rcu_bh(&rcu.head, rcu_bh_torture_wakeme_after_cb);
 	wait_for_completion(&rcu.completion);
+	destroy_rcu_head_on_stack(&rcu.head);
 }
 
 static struct rcu_torture_ops rcu_bh_ops = {
kernel/rcutree.c +4 -0
index ba69969..d443734 100644
@@ -1484,11 +1484,13 @@ void synchronize_sched(void)
 	if (rcu_blocking_is_gp())
 		return;
 
+	init_rcu_head_on_stack(&rcu.head);
 	init_completion(&rcu.completion);
 	/* Will wake me after RCU finished. */
 	call_rcu_sched(&rcu.head, wakeme_after_rcu);
 	/* Wait for it. */
 	wait_for_completion(&rcu.completion);
+	destroy_rcu_head_on_stack(&rcu.head);
 }
 EXPORT_SYMBOL_GPL(synchronize_sched);
 
@@ -1508,11 +1510,13 @@ void synchronize_rcu_bh(void)
 	if (rcu_blocking_is_gp())
 		return;
 
+	init_rcu_head_on_stack(&rcu.head);
 	init_completion(&rcu.completion);
 	/* Will wake me after RCU finished. */
 	call_rcu_bh(&rcu.head, wakeme_after_rcu);
 	/* Wait for it. */
 	wait_for_completion(&rcu.completion);
+	destroy_rcu_head_on_stack(&rcu.head);
 }
 EXPORT_SYMBOL_GPL(synchronize_rcu_bh);
 
kernel/rcutree_plugin.h +2 -0
index ac7d80f..0e4f420 100644
@@ -557,11 +557,13 @@ void synchronize_rcu(void)
 	if (!rcu_scheduler_active)
 		return;
 
+	init_rcu_head_on_stack(&rcu.head);
 	init_completion(&rcu.completion);
 	/* Will wake me after RCU finished. */
 	call_rcu(&rcu.head, wakeme_after_rcu);
 	/* Wait for it. */
 	wait_for_completion(&rcu.completion);
+	destroy_rcu_head_on_stack(&rcu.head);
 }
 EXPORT_SYMBOL_GPL(synchronize_rcu);
 
Signature · 1 line
1.7.0.6
#4 lore raw

RFC PATCH 4/11 powerpc: remove all rcu head initializations

In reply to Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

Cc Benjamin Herrenschmidt <[email protected]>
Cc Paul Mackerras <[email protected]>
---
 arch/powerpc/mm/pgtable.c |    1 -
 1 files changed, 0 insertions(+), 1 deletions(-)
arch/powerpc/mm/pgtable.c +0 -1
index ebc2f38..2c7e801 100644
@@ -92,7 +92,6 @@ static void pte_free_rcu_callback(struct rcu_head *head)
 
 static void pte_free_submit(struct pte_freelist_batch *batch)
 {
-	INIT_RCU_HEAD(&batch->rcu);
 	call_rcu(&batch->rcu, pte_free_rcu_callback);
 }
 
Signature · 1 line
1.7.0.6
#5 lore raw

RFC PATCH 5/11 block: remove all rcu head initializations

In reply to Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

---
 block/cfq-iosched.c |    1 -
 block/genhd.c       |    1 -
 2 files changed, 0 insertions(+), 2 deletions(-)
block/cfq-iosched.c +0 -1
index 5f127cf..702d006 100644
@@ -3743,7 +3743,6 @@ static void *cfq_init_queue(struct request_queue *q)
 	 * second, in order to have larger depth for async operations.
 	 */
 	cfqd->last_delayed_sync = jiffies - HZ;
-	INIT_RCU_HEAD(&cfqd->rcu);
 	return cfqd;
 }
 
block/genhd.c +0 -1
index d13ba76..27e85a2 100644
@@ -987,7 +987,6 @@ int disk_expand_part_tbl(struct gendisk *disk, int partno)
 	if (!new_ptbl)
 		return -ENOMEM;
 
-	INIT_RCU_HEAD(&new_ptbl->rcu_head);
 	new_ptbl->len = target;
 
 	for (i = 0; i < len; i++)
Signature · 1 line
1.7.0.6
#6 lore raw

RFC PATCH 6/11 staging: remove all rcu head initializations

In reply to Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

---
 drivers/staging/batman-adv/hard-interface.c |    1 -
 1 files changed, 0 insertions(+), 1 deletions(-)
drivers/staging/batman-adv/hard-interface.c +0 -1
index befd488..96ea0e5 100644
@@ -301,7 +301,6 @@ int hardif_add_interface(char *dev, int if_num)
 	batman_if->if_num = if_num;
 	batman_if->dev = dev;
 	batman_if->if_active = IF_INACTIVE;
-	INIT_RCU_HEAD(&batman_if->rcu);
 
 	printk(KERN_INFO "batman-adv:Adding interface: %s\n", dev);
 	avail_ifs++;
Signature · 1 line
1.7.0.6
Acked-by on v1 6/11
#7 lore raw

Re: [PATCH RFC tip/core/rcu 06/11] staging: remove all rcu head initializations

Quoted 9 lines · Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

---
 drivers/staging/batman-adv/hard-interface.c |    1 -

Is this safe to apply to my tree now? Or do you want to take it through your tree as it depends on other stuff?

If your tree, no objection from me, feel free to add:

thanks,

greg k-h

#8 lore raw

Re: [PATCH RFC tip/core/rcu 06/11] staging: remove all rcu head initializations

Quoted 5 lines · Greg KH
Quoted 4 lines · Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

Quoted 8 lines
Quoted 5 lines
---
 drivers/staging/batman-adv/hard-interface.c |    1 -

Is this safe to apply to my tree now? Or do you want to take it through your tree as it depends on other stuff?

Because the rcu_head in this case is not in an auto (on-stack) variable, this commit is safe to apply to your tree now.

Let me know when you have applied it, and I will happily remove it from mine. ;-)

Thanx, Paul

Quoted 6 lines

If your tree, no objection from me, feel free to add:

thanks,

greg k-h

#9 lore raw

Re: [PATCH RFC tip/core/rcu 06/11] staging: remove all rcu head initializations

Quoted 12 lines · Paul E. McKenney
Quoted 11 lines · Greg KH
Quoted 9 lines · Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

---
 drivers/staging/batman-adv/hard-interface.c |    1 -
Quoted 8 lines
Quoted 2 lines

Is this safe to apply to my tree now? Or do you want to take it through your tree as it depends on other stuff?

Because the rcu_head in this case is not in an auto (on-stack) variable, this commit is safe to apply to your tree now.

Let me know when you have applied it, and I will happily remove it from mine. ;-)

Now queued up.

thanks,

greg k-h

#10 lore raw

Re: [PATCH RFC tip/core/rcu 06/11] staging: remove all rcu head initializations

Quoted 16 lines · Greg KH
Quoted 15 lines · Paul E. McKenney
Quoted 13 lines · Greg KH
Quoted 9 lines · Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

---
 drivers/staging/batman-adv/hard-interface.c |    1 -

Is this safe to apply to my tree now? Or do you want to take it through your tree as it depends on other stuff?

Quoted 7 lines
Quoted 5 lines

Because the rcu_head in this case is not in an auto (on-stack) variable, this commit is safe to apply to your tree now.

Let me know when you have applied it, and I will happily remove it from mine. ;-)

Now queued up.

And happily removed from mine.

Thanx, Paul

#11 lore raw

RFC PATCH 7/11 fs: remove all rcu head initializations, except on_stack initializations

In reply to Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

---
 fs/file.c             |    3 ---
 fs/fs-writeback.c     |   31 ++++++++++++++++++++++++++-----
 fs/partitions/check.c |    1 -
 3 files changed, 26 insertions(+), 9 deletions(-)
fs/file.c +0 -3
index 34bb7f7..cccaead 100644
@@ -178,7 +178,6 @@ static struct fdtable * alloc_fdtable(unsigned int nr)
 	fdt->open_fds = (fd_set *)data;
 	data += nr / BITS_PER_BYTE;
 	fdt->close_on_exec = (fd_set *)data;
-	INIT_RCU_HEAD(&fdt->rcu);
 	fdt->next = NULL;
 
 	return fdt;
@@ -312,7 +311,6 @@ struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
 	new_fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;
 	new_fdt->open_fds = (fd_set *)&newf->open_fds_init;
 	new_fdt->fd = &newf->fd_array[0];
-	INIT_RCU_HEAD(&new_fdt->rcu);
 	new_fdt->next = NULL;
 
 	spin_lock(&oldf->file_lock);
@@ -430,7 +428,6 @@ struct files_struct init_files = {
 		.fd		= &init_files.fd_array[0],
 		.close_on_exec	= (fd_set *)&init_files.close_on_exec_init,
 		.open_fds	= (fd_set *)&init_files.open_fds_init,
-		.rcu		= RCU_HEAD_INIT,
 	},
 	.file_lock	= __SPIN_LOCK_UNLOCKED(init_task.file_lock),
 };
fs/fs-writeback.c +26 -5
index 4b37f7c..ea38c65 100644
@@ -75,12 +75,33 @@ static inline bool bdi_work_on_stack(struct bdi_work *work)
 	return test_bit(WS_ONSTACK_B, &work->state);
 }
 
-static inline void bdi_work_init(struct bdi_work *work,
-				 struct wb_writeback_args *args)
+static inline void __bdi_work_init(struct bdi_work *work,
+				   struct wb_writeback_args *args,
+				   int on_stack)
 {
-	INIT_RCU_HEAD(&work->rcu_head);
 	work->args = *args;
 	work->state = WS_USED;
+	if (on_stack) {
+		work->state |= WS_ONSTACK;
+		init_rcu_head_on_stack(&work->rcu_head);
+	}
+}
+
+static inline void bdi_work_init(struct bdi_work *work,
+				 struct wb_writeback_args *args)
+{
+	__bdi_work_init(work, args, false);
+}
+
+static inline void bdi_work_init_on_stack(struct bdi_work *work,
+					  struct wb_writeback_args *args)
+{
+	__bdi_work_init(work, args, true);
+}
+
+static inline void bdi_destroy_work_on_stack(struct bdi_work *work)
+{
+	destroy_rcu_head_on_stack(&work->rcu_head);
 }
 
 /**
@@ -233,11 +254,11 @@ static void bdi_sync_writeback(struct backing_dev_info *bdi,
 	};
 	struct bdi_work work;
 
-	bdi_work_init(&work, &args);
-	work.state |= WS_ONSTACK;
+	bdi_work_init_on_stack(&work, &args);
 
 	bdi_queue_work(bdi, &work);
 	bdi_wait_on_work_clear(&work);
+	bdi_destroy_work_on_stack(&work);
 }
 
 /**
fs/partitions/check.c +0 -1
index e238ab2..7444e6f 100644
@@ -456,7 +456,6 @@ struct hd_struct *add_partition(struct gendisk *disk, int partno,
 	}
 
 	/* everything is up and running, commence */
-	INIT_RCU_HEAD(&p->rcu_head);
 	rcu_assign_pointer(ptbl->part[partno], p);
 
 	/* suppress uevent if the disk supresses it */
Signature · 1 line
1.7.0.6
#12 lore raw

RFC PATCH 8/11 mm: remove all rcu head initializations

In reply to Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

Cc Cc: Christoph Lameter <[email protected]>
Cc Pekka Enberg <[email protected]>
Cc Matt Mackall <[email protected]>
Cc Andrew Morton <[email protected]>
---
 mm/backing-dev.c |    1 -
 mm/slob.c        |    1 -
 2 files changed, 0 insertions(+), 2 deletions(-)
mm/backing-dev.c +0 -1
index 707d0dc..f03d8d6 100644
@@ -663,7 +663,6 @@ int bdi_init(struct backing_dev_info *bdi)
 	bdi->max_ratio = 100;
 	bdi->max_prop_frac = PROP_FRAC_BASE;
 	spin_lock_init(&bdi->wb_lock);
-	INIT_RCU_HEAD(&bdi->rcu_head);
 	INIT_LIST_HEAD(&bdi->bdi_list);
 	INIT_LIST_HEAD(&bdi->wb_list);
 	INIT_LIST_HEAD(&bdi->work_list);
mm/slob.c +0 -1
index 837ebd6..6de238d 100644
@@ -647,7 +647,6 @@ void kmem_cache_free(struct kmem_cache *c, void *b)
 	if (unlikely(c->flags & SLAB_DESTROY_BY_RCU)) {
 		struct slob_rcu *slob_rcu;
 		slob_rcu = b + (c->size - sizeof(struct slob_rcu));
-		INIT_RCU_HEAD(&slob_rcu->head);
 		slob_rcu->size = c->size;
 		call_rcu(&slob_rcu->head, kmem_rcu_free);
 	} else {
Signature · 1 line
1.7.0.6
#13 lore raw

RFC PATCH 9/11 selinux: remove all rcu head initializations

In reply to Paul E. McKenney

Remove all rcu head inits. We don't care about the RCU head state before passing it to call_rcu() anyway. Only leave the "on_stack" variants so debugobjects can keep track of objects on stack.

---
 security/selinux/avc.c     |    1 -
 security/selinux/netnode.c |    2 --
 2 files changed, 0 insertions(+), 3 deletions(-)
security/selinux/avc.c +0 -1
index 989fef8..bf4e3bc 100644
@@ -288,7 +288,6 @@ static struct avc_node *avc_alloc_node(void)
 	if (!node)
 		goto out;
 
-	INIT_RCU_HEAD(&node->rhead);
 	INIT_HLIST_NODE(&node->list);
 	avc_cache_stats_incr(allocations);
 
security/selinux/netnode.c +0 -2
index dc92792..65ebfe9 100644
@@ -183,8 +183,6 @@ static void sel_netnode_insert(struct sel_netnode *node)
 		BUG();
 	}
 
-	INIT_RCU_HEAD(&node->rcu);
-
 	/* we need to impose a limit on the growth of the hash table so check
 	 * this bucket to make sure it is within the specified bounds */
 	list_add_rcu(&node->list, &sel_netnode_hash[idx].list);
Signature · 1 line
1.7.0.6
#14 lore raw

RFC PATCH 10/11 rcu head remove init

In reply to Paul E. McKenney

From: Mathieu Desnoyers <[email protected]>

RCU heads really don't need to be initialized. Their state before call_rcu() really does not matter.

We need to keep init/destroy_rcu_head_on_stack() though, since we want debugobjects to be able to keep track of these objects.

---
 include/linux/rcupdate.h |    6 ------
 1 files changed, 0 insertions(+), 6 deletions(-)
include/linux/rcupdate.h +0 -6
index b653b4a..3a1a70d 100644
@@ -73,12 +73,6 @@ extern void rcu_init(void);
 #error "Unknown RCU implementation specified to kernel configuration"
 #endif
 
-#define RCU_HEAD_INIT	{ .next = NULL, .func = NULL }
-#define RCU_HEAD(head) struct rcu_head head = RCU_HEAD_INIT
-#define INIT_RCU_HEAD(ptr) do { \
-       (ptr)->next = NULL; (ptr)->func = NULL; \
-} while (0)
-
 static inline void init_rcu_head_on_stack(struct rcu_head *head)
 {
 }
Signature · 1 line
1.7.0.6
#15 lore raw

RFC PATCH 11/11 tree/tiny rcu: Add debug RCU head objects (v5)

In reply to Paul E. McKenney

From: Mathieu Desnoyers <[email protected]>

Helps finding racy users of call_rcu(), which results in hangs because list entries are overwritten and/or skipped.

Changelog since v4:
- Bissectability is now OK
- Now generate a WARN_ON_ONCE() for non-initialized rcu_head passed to call_rcu(). Statically initialized objects are detected with object_is_static().
- Rename rcu_head_init_on_stack to init_rcu_head_on_stack.
- Remove init_rcu_head() completely.

Changelog since v3:
- Include comments from Lai Jiangshan

This new patch version is based on the debugobjects with the newly introduced "active state" tracker.

Non-initialized entries are all considered as "statically initialized". An activation fixup (triggered by call_rcu()) takes care of performing the debug object initialization without issuing any warning. Since we cannot increase the size of struct rcu_head, I don't see much room to put an identifier for statically initialized rcu_head structures. So for now, we have to live without "activation without explicit init" detection. But the main purpose of this debug option is to detect double-activations (double call_rcu() use of a rcu_head before the callback is executed), which is correctly addressed here.

This also detects potential internal RCU callback corruption, which would cause the callbacks to be executed twice.

---
 include/linux/rcupdate.h |   49 +++++++++++++
 kernel/rcupdate.c        |  170 ++++++++++++++++++++++++++++++++++++++++++++++
 kernel/rcutiny.c         |    2 +
 kernel/rcutree.c         |    2 +
 lib/Kconfig.debug        |    6 ++
 5 files changed, 229 insertions(+), 0 deletions(-)
include/linux/rcupdate.h +49 -0
index 3a1a70d..2f9e56c 100644
@@ -40,6 +40,7 @@
 #include <linux/seqlock.h>
 #include <linux/lockdep.h>
 #include <linux/completion.h>
+#include <linux/debugobjects.h>
 
 #ifdef CONFIG_RCU_TORTURE_TEST
 extern int rcutorture_runnable; /* for sysctl */
@@ -73,6 +74,16 @@ extern void rcu_init(void);
 #error "Unknown RCU implementation specified to kernel configuration"
 #endif
 
+/*
+ * init_rcu_head_on_stack()/destroy_rcu_head_on_stack() are needed for dynamic
+ * initialization and destruction of rcu_head on the stack. rcu_head structures
+ * allocated dynamically in the heap or defined statically don't need any
+ * initialization.
+ */
+#ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD
+extern void init_rcu_head_on_stack(struct rcu_head *head);
+extern void destroy_rcu_head_on_stack(struct rcu_head *head);
+#else /* !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
 static inline void init_rcu_head_on_stack(struct rcu_head *head)
 {
 }
@@ -80,6 +91,7 @@ static inline void init_rcu_head_on_stack(struct rcu_head *head)
 static inline void destroy_rcu_head_on_stack(struct rcu_head *head)
 {
 }
+#endif	/* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 
@@ -511,4 +523,41 @@ extern void call_rcu(struct rcu_head *head,
 extern void call_rcu_bh(struct rcu_head *head,
 			void (*func)(struct rcu_head *head));
 
+/*
+ * debug_rcu_head_queue()/debug_rcu_head_unqueue() are used internally
+ * by call_rcu() and rcu callback execution, and are therefore not part of the
+ * RCU API. Leaving in rcupdate.h because they are used by all RCU flavors.
+ */
+
+#ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD
+# define STATE_RCU_HEAD_READY	0
+# define STATE_RCU_HEAD_QUEUED	1
+
+extern struct debug_obj_descr rcuhead_debug_descr;
+
+static inline void debug_rcu_head_queue(struct rcu_head *head)
+{
+	debug_object_activate(head, &rcuhead_debug_descr);
+	debug_object_active_state(head, &rcuhead_debug_descr,
+				  STATE_RCU_HEAD_READY,
+				  STATE_RCU_HEAD_QUEUED);
+}
+
+static inline void debug_rcu_head_unqueue(struct rcu_head *head)
+{
+	debug_object_active_state(head, &rcuhead_debug_descr,
+				  STATE_RCU_HEAD_QUEUED,
+				  STATE_RCU_HEAD_READY);
+	debug_object_deactivate(head, &rcuhead_debug_descr);
+}
+#else	/* !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
+static inline void debug_rcu_head_queue(struct rcu_head *head)
+{
+}
+
+static inline void debug_rcu_head_unqueue(struct rcu_head *head)
+{
+}
+#endif	/* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
+
 #endif /* __LINUX_RCUPDATE_H */
kernel/rcupdate.c +170 -0

173 lines not on this page · raw message

kernel/rcutiny.c +2 -0
index 38729d3..196ec02 100644
@@ -169,6 +169,7 @@ static void __rcu_process_callbacks(struct rcu_ctrlblk *rcp)
 	while (list) {
 		next = list->next;
 		prefetch(next);
+		debug_rcu_head_unqueue(list);
 		list->func(list);
 		list = next;
 	}
@@ -211,6 +212,7 @@ static void __call_rcu(struct rcu_head *head,
 {
 	unsigned long flags;
 
+	debug_rcu_head_queue(head);
 	head->func = func;
 	head->next = NULL;
 
kernel/rcutree.c +2 -0
index d443734..d5bc439 100644
@@ -1112,6 +1112,7 @@ static void rcu_do_batch(struct rcu_state *rsp, struct rcu_data *rdp)
 	while (list) {
 		next = list->next;
 		prefetch(next);
+		debug_rcu_head_unqueue(list);
 		list->func(list);
 		list = next;
 		if (++count >= rdp->blimit)
@@ -1388,6 +1389,7 @@ __call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu),
 	unsigned long flags;
 	struct rcu_data *rdp;
 
+	debug_rcu_head_queue(head);
 	head->func = func;
 	head->next = NULL;
 
lib/Kconfig.debug +6 -0
index 930a9e5..8689646 100644
@@ -307,6 +307,12 @@ config DEBUG_OBJECTS_WORK
 	  work queue routines to track the life time of work objects and
 	  validate the work operations.
 
+config DEBUG_OBJECTS_RCU_HEAD
+	bool "Debug RCU callbacks objects"
+	depends on DEBUG_OBJECTS
+	help
+	  Enable this to turn on debugging of RCU list heads (call_rcu() usage).
+
 config DEBUG_OBJECTS_ENABLE_DEFAULT
 	int "debug_objects bootup default value (0-1)"
         range 0 1
Signature · 1 line
1.7.0.6