kernfs: Separate kernfs_pr_cont_buf and rename_lock.
PATCH 1/1 kernfs: Separate kernfs_pr_cont_buf and rename_lock.
Previously the protection of kernfs_pr_cont_buf was piggy backed by rename_lock, which means that pr_cont() needs to be protected under rename_lock. This can cause potential circular lock dependencies.
If there is an OOM, we have the following call hierarchy:
-> cpuset_print_current_mems_allowed()
-> pr_cont_cgroup_name()
-> pr_cont_kernfs_name()
pr_cont_kernfs_name() will grab rename_lock and call printk. So we have the following lock dependencies:
kernfs_rename_lock -> console_sem
Sometimes, printk does a wakeup before releasing console_sem, which has the dependence chain:
console_sem -> p->pi_lock -> rq->lock
Now, imagine one wants to read cgroup_name under rq->lock, for example, printing cgroup_name in a tracepoint in the scheduler code. They will be holding rq->lock and take rename_lock:
rq->lock -> kernfs_rename_lock
Now they will deadlock.
A prevention to this circular lock dependency is to separate the protection of pr_cont_buf from rename_lock. In principle, rename_lock is to protect the integrity of cgroup name when copying to buf. Once pr_cont_buf has got its content, rename_lock can be dropped. So it's safe to drop rename_lock after kernfs_name_locked (and kernfs_path_from_node_locked) and rely on a dedicated pr_cont_lock to protect pr_cont_buf.
--- fs/kernfs/dir.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-)
fs/kernfs/dir.c +12 -12
@@ -18,7 +18,8 @@#include "kernfs-internal.h" static DEFINE_SPINLOCK (kernfs_rename_lock);/* kn->parent and ->name */ -static char kernfs_pr_cont_buf[PATH_MAX ];/* protected by rename_lock */ +static DEFINE_SPINLOCK (kernfs_pr_cont_lock); +static char kernfs_pr_cont_buf[PATH_MAX ];/* protected by pr_cont_lock */ static DEFINE_SPINLOCK (kernfs_idr_lock);/* root->ino_idr */ #define rb_to_kn (X ) rb_entry((X), struct kernfs_node, rb)
@@ -229,12 +230,12 @@ void pr_cont_kernfs_name(struct kernfs_node *kn) {unsigned long flags; -spin_lock_irqsave (&kernfs_rename_lock, flags); +spin_lock_irqsave (&kernfs_pr_cont_lock, flags); -kernfs_name_locked (kn, kernfs_pr_cont_buf,sizeof (kernfs_pr_cont_buf)); +kernfs_name (kn, kernfs_pr_cont_buf,sizeof (kernfs_pr_cont_buf));pr_cont ("%s" , kernfs_pr_cont_buf); -spin_unlock_irqrestore (&kernfs_rename_lock, flags); +spin_unlock_irqrestore (&kernfs_pr_cont_lock, flags); }/**
@@ -248,10 +249,10 @@ void pr_cont_kernfs_path(struct kernfs_node *kn)unsigned long flags;int sz; -spin_lock_irqsave (&kernfs_rename_lock, flags); +spin_lock_irqsave (&kernfs_pr_cont_lock, flags); - sz =kernfs_path_from_node_locked (kn,NULL , kernfs_pr_cont_buf, -sizeof (kernfs_pr_cont_buf)); + sz =kernfs_path_from_node (kn,NULL , kernfs_pr_cont_buf, +sizeof (kernfs_pr_cont_buf));if (sz <0 ) {pr_cont ("(error)" ); goto out;
@@ -265,7 +266,7 @@ void pr_cont_kernfs_path(struct kernfs_node *kn)pr_cont ("%s" , kernfs_pr_cont_buf); out: -spin_unlock_irqrestore (&kernfs_rename_lock, flags); +spin_unlock_irqrestore (&kernfs_pr_cont_lock, flags); }/**
@@ -823,13 +824,12 @@ static struct kernfs_node *kernfs_walk_ns(struct kernfs_node *parent,lockdep_assert_held_read (&kernfs_root (parent)->kernfs_rwsem); -/* grab kernfs_rename_lock to piggy back on kernfs_pr_cont_buf */ -spin_lock_irq (&kernfs_rename_lock); +spin_lock_irq (&kernfs_pr_cont_lock); len =strlcpy (kernfs_pr_cont_buf, path,sizeof (kernfs_pr_cont_buf));if (len >=sizeof (kernfs_pr_cont_buf)) { -spin_unlock_irq (&kernfs_rename_lock); +spin_unlock_irq (&kernfs_pr_cont_lock);return NULL ; }
@@ -841,7 +841,7 @@ static struct kernfs_node *kernfs_walk_ns(struct kernfs_node *parent, parent =kernfs_find_ns (parent, name, ns); } -spin_unlock_irq (&kernfs_rename_lock); +spin_unlock_irq (&kernfs_pr_cont_lock);return parent; }
Signature · 1 line
2.36.1.124.g0e6072fb45-goog
Quoted 36 lines · Hao Luo
Previously the protection of
kernfs_pr_cont_bufwas piggy backed byrename_lock, which means thatpr_cont()needs to be protected underrename_lock. This can cause potential circular lock dependencies.If there is an OOM, we have the following call hierarchy:
->
cpuset_print_current_mems_allowed()
->pr_cont_cgroup_name()-> pr_cont_kernfs_name()
pr_cont_kernfs_name()will grabrename_lockand call printk. So we have the following lock dependencies:
kernfs_rename_lock->console_semSometimes, printk does a wakeup before releasing
console_sem, which has the dependence chain:
console_sem->p->pi_lock->rq->lockNow, imagine one wants to read
cgroup_nameunderrq->lock, for example, printingcgroup_namein a tracepoint in the scheduler code. They will be holdingrq->lockand takerename_lock:
rq->lock->kernfs_rename_lockNow they will deadlock.
A prevention to this circular lock dependency is to separate the protection of
pr_cont_buffromrename_lock. In principle,rename_lockis to protect the integrity of cgroup name when copying to buf. Oncepr_cont_bufhas got its content,rename_lockcan be dropped. So it's safe to droprename_lockafterkernfs_name_locked(andkernfs_path_from_node_locked) and rely on a dedicatedpr_cont_lockto protectpr_cont_buf.
Quoted 1 line
Signed-off-by Hao Luo <[email protected]>
Can you please add a comment explaining why the lock is separate? Other than that:
Thanks.
Signature · 1 line
tejun
Quoted 7 lines · Tejun Heo
Can you please add a comment explaining why the lock is separate? Other than that:
Acked-by Tejun Heo <[email protected]>Thanks.
Sure, will do and resend.
Quoted 3 lines
--
tejun