Lock ordering documentation and annotation for lockdep
Subsystems (25)
v3 cover Lock ordering documentation and annotation for lockdep
This is the third and hopefully final version of this work. The second one can be found here:
https://lore.kernel.org/r/[email protected]
Changes since V2:
- Included the arch/XXX fixups for the rcuwait changes (Sebastian)
- Folded the init fix for the PS3 change (Sebastian)
- Addressed feedback on documentation (Paul, Davidlohr, Jonathan)
- Picked up acks and reviewed tags
Thanks,
tglx
PATCH v3 1/20 PCI/switchtec: Fix init_completion race condition with poll_wait()
From: Logan Gunthorpe <[email protected]>
The call to init_completion() in mrpc_queue_cmd() can theoretically race with the call to poll_wait() in switchtec_dev_poll().
poll() write()
switchtec_dev_poll() switchtec_dev_write()
poll_wait(&s->comp.wait); mrpc_queue_cmd()
init_completion(&s->comp)
init_waitqueue_head(&s->comp.wait)To my knowledge, no one has hit this bug.
Fix this by using reinit_completion() instead of init_completion() in mrpc_queue_cmd().
--- drivers/pci/switch/switchtec.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/pci/switch/switchtec.c +1 -1
@@ -175,7 +175,7 @@ static int mrpc_queue_cmd(struct switchtec_user *stuser)kref_get (&stuser->kref); stuser->read_len =sizeof (stuser->data);stuser_set_state (stuser,MRPC_QUEUED ); -init_completion (&stuser->comp); +reinit_completion (&stuser->comp);list_add_tail (&stuser->list, &stdev->mrpc_queue);mrpc_cmd_submit (stdev);
Signature · 1 line
2.20.1
PATCH v3 2/20 pci/switchtec: Replace completion wait queue usage for poll
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
The poll callback is using the completion wait queue and sticks it into poll_wait() to wake up pollers after a command has completed.
This works to some extent, but cannot provide EPOLLEXCLUSIVE support because the waker side uses complete_all() which unconditionally wakes up all waiters. complete_all() is required because completions internally use exclusive wait and complete() only wakes up one waiter by default.
This mixes conceptually different mechanisms and relies on internal implementation details of completions, which in turn puts contraints on changing the internal implementation of completions.
Replace it with a regular wait queue and store the state in struct switchtec_user.
---
V2: Reworded changelog.
--- drivers/pci/switch/switchtec.c | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-)
drivers/pci/switch/switchtec.c +13 -9
@@ -52,10 +52,11 @@ struct switchtec_user {enum mrpc_state state; -struct completion comp; +wait_queue_head_t cmd_comp;struct kref kref;struct list_head list; +bool cmd_done;u32 cmd;u32 status;u32 return_code;
@@ -77,7 +78,7 @@ static struct switchtec_user *stuser_cre stuser->stdev = stdev;kref_init (&stuser->kref);INIT_LIST_HEAD (&stuser->list); -init_completion (&stuser->comp); +init_waitqueue_head (&stuser->cmd_comp); stuser->event_cnt =atomic_read (&stdev->event_cnt);dev_dbg (&stdev->dev,"%s: %p\n" , __func__, stuser);
@@ -175,7 +176,7 @@ static int mrpc_queue_cmd(struct switchtkref_get (&stuser->kref); stuser->read_len =sizeof (stuser->data);stuser_set_state (stuser,MRPC_QUEUED ); -reinit_completion (&stuser->comp); + stuser->cmd_done = false;list_add_tail (&stuser->list, &stdev->mrpc_queue);mrpc_cmd_submit (stdev);
@@ -222,7 +223,8 @@ static void mrpc_complete_cmd(struct swimemcpy_fromio (stuser->data, &stdev->mmio_mrpc->output_data, stuser->read_len); out: -complete_all (&stuser->comp); + stuser->cmd_done = true; +wake_up_interruptible (&stuser->cmd_comp);list_del_init (&stuser->list);stuser_put (stuser); stdev->mrpc_busy =0 ;
@@ -529,10 +531,11 @@ static ssize_t switchtec_dev_read(structmutex_unlock (&stdev->mrpc_mutex);if (filp->f_flags &O_NONBLOCK ) { -if (!try_wait_for_completion (&stuser->comp)) +if (!stuser->cmd_done)return -EAGAIN ; }else { - rc =wait_for_completion_interruptible (&stuser->comp); + rc =wait_event_interruptible (stuser->cmd_comp, + stuser->cmd_done);if (rc <0 )return rc; }
@@ -580,7 +583,7 @@ static __poll_t switchtec_dev_poll(strucstruct switchtec_dev *stdev = stuser->stdev;__poll_t ret =0 ; -poll_wait (filp, &stuser->comp.wait, wait); +poll_wait (filp, &stuser->cmd_comp, wait);poll_wait (filp, &stdev->event_wq, wait);if (lock_mutex_and_test_alive (stdev))
@@ -588,7 +591,7 @@ static __poll_t switchtec_dev_poll(strucmutex_unlock (&stdev->mrpc_mutex); -if (try_wait_for_completion (&stuser->comp)) +if (stuser->cmd_done) ret |=EPOLLIN |EPOLLRDNORM ;if (stuser->event_cnt !=atomic_read (&stdev->event_cnt))
@@ -1272,7 +1275,8 @@ static void stdev_kill(struct switchtec_/* Wake up and kill any users waiting on an MRPC request */ list_for_each_entry_safe (stuser, tmpuser, &stdev->mrpc_queue, list) { -complete_all (&stuser->comp); + stuser->cmd_done = true; +wake_up_interruptible (&stuser->cmd_comp);list_del_init (&stuser->list);stuser_put (stuser); }
[tip: locking/core] pci/switchtec: Replace completion wait queue usage for poll
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: deaa0a8a74d86573f190e21ae9a444ea5e3bceee Gitweb: https://git.kernel.org/tip/deaa0a8a74d86573f190e21ae9a444ea5e3bceee Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:46 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:20 +01:00
pci/switchtec: Replace completion wait queue usage for poll
The poll callback is using the completion wait queue and sticks it into poll_wait() to wake up pollers after a command has completed.
This works to some extent, but cannot provide EPOLLEXCLUSIVE support because the waker side uses complete_all() which unconditionally wakes up all waiters. complete_all() is required because completions internally use exclusive wait and complete() only wakes up one waiter by default.
This mixes conceptually different mechanisms and relies on internal implementation details of completions, which in turn puts contraints on changing the internal implementation of completions.
Replace it with a regular wait queue and store the state in struct switchtec_user.
--- drivers/pci/switch/switchtec.c | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-)
drivers/pci/switch/switchtec.c +13 -9
@@ -52,10 +52,11 @@ struct switchtec_user {enum mrpc_state state; -struct completion comp; +wait_queue_head_t cmd_comp;struct kref kref;struct list_head list; +bool cmd_done;u32 cmd;u32 status;u32 return_code;
@@ -77,7 +78,7 @@ static struct switchtec_user *stuser_create(struct switchtec_dev *stdev) stuser->stdev = stdev;kref_init (&stuser->kref);INIT_LIST_HEAD (&stuser->list); -init_completion (&stuser->comp); +init_waitqueue_head (&stuser->cmd_comp); stuser->event_cnt =atomic_read (&stdev->event_cnt);dev_dbg (&stdev->dev,"%s: %p\n" , __func__, stuser);
@@ -175,7 +176,7 @@ static int mrpc_queue_cmd(struct switchtec_user *stuser)kref_get (&stuser->kref); stuser->read_len =sizeof (stuser->data);stuser_set_state (stuser,MRPC_QUEUED ); -reinit_completion (&stuser->comp); + stuser->cmd_done = false;list_add_tail (&stuser->list, &stdev->mrpc_queue);mrpc_cmd_submit (stdev);
@@ -222,7 +223,8 @@ static void mrpc_complete_cmd(struct switchtec_dev *stdev)memcpy_fromio (stuser->data, &stdev->mmio_mrpc->output_data, stuser->read_len); out: -complete_all (&stuser->comp); + stuser->cmd_done = true; +wake_up_interruptible (&stuser->cmd_comp);list_del_init (&stuser->list);stuser_put (stuser); stdev->mrpc_busy =0 ;
@@ -529,10 +531,11 @@ static ssize_t switchtec_dev_read(struct file *filp, char __user *data,mutex_unlock (&stdev->mrpc_mutex);if (filp->f_flags &O_NONBLOCK ) { -if (!try_wait_for_completion (&stuser->comp)) +if (!stuser->cmd_done)return -EAGAIN ; }else { - rc =wait_for_completion_interruptible (&stuser->comp); + rc =wait_event_interruptible (stuser->cmd_comp, + stuser->cmd_done);if (rc <0 )return rc; }
@@ -580,7 +583,7 @@ static __poll_t switchtec_dev_poll(struct file *filp, poll_table *wait)struct switchtec_dev *stdev = stuser->stdev;__poll_t ret =0 ; -poll_wait (filp, &stuser->comp.wait, wait); +poll_wait (filp, &stuser->cmd_comp, wait);poll_wait (filp, &stdev->event_wq, wait);if (lock_mutex_and_test_alive (stdev))
@@ -588,7 +591,7 @@ static __poll_t switchtec_dev_poll(struct file *filp, poll_table *wait)mutex_unlock (&stdev->mrpc_mutex); -if (try_wait_for_completion (&stuser->comp)) +if (stuser->cmd_done) ret |=EPOLLIN |EPOLLRDNORM ;if (stuser->event_cnt !=atomic_read (&stdev->event_cnt))
@@ -1272,7 +1275,8 @@ static void stdev_kill(struct switchtec_dev *stdev)/* Wake up and kill any users waiting on an MRPC request */ list_for_each_entry_safe (stuser, tmpuser, &stdev->mrpc_queue, list) { -complete_all (&stuser->comp); + stuser->cmd_done = true; +wake_up_interruptible (&stuser->cmd_comp);list_del_init (&stuser->list);stuser_put (stuser); }
PATCH v3 3/20 usb: gadget: Use completion interface instead of open coding it
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
ep_io() uses a completion on stack and open codes the waiting with:
wait_event_interruptible (done.wait, done.done);
and
wait_event (done.wait, done.done);
This waits in non-exclusive mode for complete(), but there is no reason to do so because the completion can only be waited for by the task itself and complete() wakes exactly one exlusive waiter.
Replace the open coded implementation with the corresponding wait_for_completion*() functions.
No functional change.
---
V2: New patch to avoid the conversion to swait interfaces later
--- drivers/usb/gadget/legacy/inode.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/usb/gadget/legacy/inode.c +2 -2
@@ -344,7 +344,7 @@ ep_io (struct ep_data *epdata, void *bufspin_unlock_irq (&epdata->dev->lock);if (likely (value ==0 )) { - value =wait_event_interruptible (done.wait, done.done); + value =wait_for_completion_interruptible (&done);if (value !=0 ) {spin_lock_irq (&epdata->dev->lock);if (likely (epdata->ep !=NULL )) {
@@ -353,7 +353,7 @@ ep_io (struct ep_data *epdata, void *bufusb_ep_dequeue (epdata->ep, epdata->req);spin_unlock_irq (&epdata->dev->lock); -wait_event (done.wait, done.done); +wait_for_completion (&done);if (epdata->status == -ECONNRESET ) epdata->status = -EINTR ; }else {
[tip: locking/core] usb: gadget: Use completion interface instead of open coding it
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: c1d51dd505577b189bf33867a9c20015ca7efb46 Gitweb: https://git.kernel.org/tip/c1d51dd505577b189bf33867a9c20015ca7efb46 Author: Thomas Gleixner <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:47 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:20 +01:00
usb: gadget: Use completion interface instead of open coding it
ep_io() uses a completion on stack and open codes the waiting with:
wait_event_interruptible (done.wait, done.done);
and
wait_event (done.wait, done.done);
This waits in non-exclusive mode for complete(), but there is no reason to do so because the completion can only be waited for by the task itself and complete() wakes exactly one exlusive waiter.
Replace the open coded implementation with the corresponding wait_for_completion*() functions.
No functional change.
--- drivers/usb/gadget/legacy/inode.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/usb/gadget/legacy/inode.c +2 -2
@@ -344,7 +344,7 @@ ep_io (struct ep_data *epdata, void *buf, unsigned len)spin_unlock_irq (&epdata->dev->lock);if (likely (value ==0 )) { - value =wait_event_interruptible (done.wait, done.done); + value =wait_for_completion_interruptible (&done);if (value !=0 ) {spin_lock_irq (&epdata->dev->lock);if (likely (epdata->ep !=NULL )) {
@@ -353,7 +353,7 @@ ep_io (struct ep_data *epdata, void *buf, unsigned len)usb_ep_dequeue (epdata->ep, epdata->req);spin_unlock_irq (&epdata->dev->lock); -wait_event (done.wait, done.done); +wait_for_completion (&done);if (epdata->status == -ECONNRESET ) epdata->status = -EINTR ; }else {
Re: [patch V3 03/20] usb: gadget: Use completion interface instead of open coding it
In reply to Thomas GleixnerQuoted 15 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
ep_io()uses a completion on stack and open codes the waiting with:
wait_event_interruptible(done.wait, done.done);
and
wait_event(done.wait, done.done);This waits in non-exclusive mode for
complete(), but there is no reason to do so because the completion can only be waited for by the task itself andcomplete()wakes exactly one exlusive waiter.Replace the open coded implementation with the corresponding wait_for_completion*() functions.
Quoted 7 lines
No functional change.
Reported-by Sebastian Andrzej Siewior <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>Reviewed-by Greg Kroah-Hartman <[email protected]>Cc Felipe Balbi <[email protected]>
Do you want to carry it via your tree? If so:
Otherwise, let me know and I'll pick this patch.
Signature · 1 line
balbi
Re: [patch V3 03/20] usb: gadget: Use completion interface instead of open coding it
Quoted 1 line · Felipe Balbi
Do you want to carry it via your tree? If so:
We would like to do so.
Quoted 1 line
Acked-by Felipe Balbi <[email protected]>
Thank you.
Quoted 1 line
Otherwise, let me know and I'll pick this patch.
Sebastian
PATCH v3 4/20 orinoco_usb: Use the regular completion interfaces
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
The completion usage in this driver is interesting:
- it uses a magic complete function which according to the comment was implemented by invoking complete() four times in a row because complete_all() was not exported at that time.
- it uses an open coded wait/poll which checks completion:done. Only one wait side (device removal) uses the regular wait_for_completion() interface.
The rationale behind this is to prevent that wait_for_completion() consumes completion::done which would prevent that all waiters are woken. This is not necessary with complete_all() as that sets completion::done to UINT_MAX which is left unmodified by the woken waiters.
Replace the magic complete function with complete_all() and convert the open coded wait/poll to regular completion interfaces.
This changes the wait to exclusive wait mode. But that does not make any difference because the wakers use complete_all() which ignores the exclusive mode.
---
V2: New patch to avoid conversion to swait functions later.
--- drivers/net/wireless/intersil/orinoco/orinoco_usb.c | 21 ++++---------------- 1 file changed, 5 insertions(+), 16 deletions(-)
drivers/net/wireless/intersil/orinoco/orinoco_usb.c +5 -16
@@ -365,17 +365,6 @@ static struct request_context *ezusb_allreturn ctx; } - -/* Hopefully the real complete_all will soon be exported, in the mean -* while this should work. */ -static inline void ezusb_complete_all (struct completion *comp) -{ -complete (comp); -complete (comp); -complete (comp); -complete (comp); -} -static void ezusb_ctx_complete (struct request_context *ctx) {struct ezusb_priv *upriv = ctx->upriv;
@@ -409,7 +398,7 @@ static void ezusb_ctx_complete(struct renetif_wake_queue (dev); } -ezusb_complete_all (&ctx->done); +complete_all (&ctx->done);ezusb_request_context_put (ctx);break ;
@@ -419,7 +408,7 @@ static void ezusb_ctx_complete(struct re/* This is normal, as all request contexts get flushed * when the device is disconnected */ err ("Called, CTX not terminating, but device gone" ); -ezusb_complete_all (&ctx->done); +complete_all (&ctx->done);ezusb_request_context_put (ctx);break ; }
@@ -690,11 +679,11 @@ static void ezusb_req_ctx_wait(struct ez* get the chance to run themselves. So we make sure * that we don't sleep for ever */ int msecs =DEF_TIMEOUT * (1000 /HZ ); -while (!ctx->done.done && msecs--) + +while (!try_wait_for_completion (&ctx->done) && msecs--)udelay (1000 ); }else { -wait_event_interruptible (ctx->done.wait, - ctx->done.done); +wait_for_completion (&ctx->done); }break ;default :
[tip: locking/core] orinoco_usb: Use the regular completion interfaces
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 9fe114ce0371223d2a0490f0aa52b8f108d92f37 Gitweb: https://git.kernel.org/tip/9fe114ce0371223d2a0490f0aa52b8f108d92f37 Author: Thomas Gleixner <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:48 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:20 +01:00
orinoco_usb: Use the regular completion interfaces
The completion usage in this driver is interesting:
- it uses a magic complete function which according to the comment was implemented by invoking complete() four times in a row because complete_all() was not exported at that time.
- it uses an open coded wait/poll which checks completion:done. Only one wait side (device removal) uses the regular wait_for_completion() interface.
The rationale behind this is to prevent that wait_for_completion() consumes completion::done which would prevent that all waiters are woken. This is not necessary with complete_all() as that sets completion::done to UINT_MAX which is left unmodified by the woken waiters.
Replace the magic complete function with complete_all() and convert the open coded wait/poll to regular completion interfaces.
This changes the wait to exclusive wait mode. But that does not make any difference because the wakers use complete_all() which ignores the exclusive mode.
--- drivers/net/wireless/intersil/orinoco/orinoco_usb.c | 21 ++---------- 1 file changed, 5 insertions(+), 16 deletions(-)
drivers/net/wireless/intersil/orinoco/orinoco_usb.c +5 -16
@@ -365,17 +365,6 @@ static struct request_context *ezusb_alloc_ctx(struct ezusb_priv *upriv,return ctx; } - -/* Hopefully the real complete_all will soon be exported, in the mean -* while this should work. */ -static inline void ezusb_complete_all (struct completion *comp) -{ -complete (comp); -complete (comp); -complete (comp); -complete (comp); -} -static void ezusb_ctx_complete (struct request_context *ctx) {struct ezusb_priv *upriv = ctx->upriv;
@@ -409,7 +398,7 @@ static void ezusb_ctx_complete(struct request_context *ctx)netif_wake_queue (dev); } -ezusb_complete_all (&ctx->done); +complete_all (&ctx->done);ezusb_request_context_put (ctx);break ;
@@ -419,7 +408,7 @@ static void ezusb_ctx_complete(struct request_context *ctx)/* This is normal, as all request contexts get flushed * when the device is disconnected */ err ("Called, CTX not terminating, but device gone" ); -ezusb_complete_all (&ctx->done); +complete_all (&ctx->done);ezusb_request_context_put (ctx);break ; }
@@ -690,11 +679,11 @@ static void ezusb_req_ctx_wait(struct ezusb_priv *upriv,* get the chance to run themselves. So we make sure * that we don't sleep for ever */ int msecs =DEF_TIMEOUT * (1000 /HZ ); -while (!ctx->done.done && msecs--) + +while (!try_wait_for_completion (&ctx->done) && msecs--)udelay (1000 ); }else { -wait_event_interruptible (ctx->done.wait, - ctx->done.done); +wait_for_completion (&ctx->done); }break ;default :
Re: [patch V3 04/20] orinoco_usb: Use the regular completion interfaces
In reply to Thomas GleixnerQuoted 31 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
The completion usage in this driver is interesting:
- it uses a magic complete function which according to the comment was implemented by invoking
complete()four times in a row becausecomplete_all()was not exported at that time.- it uses an open coded wait/poll which checks completion:done. Only one wait side (device removal) uses the regular
wait_for_completion()interface.The rationale behind this is to prevent that
wait_for_completion()consumescompletion::donewhich would prevent that all waiters are woken. This is not necessary withcomplete_all()as that setscompletion::donetoUINT_MAXwhich is left unmodified by the woken waiters.Replace the magic complete function with
complete_all()and convert the open coded wait/poll to regular completion interfaces.This changes the wait to exclusive wait mode. But that does not make any difference because the wakers use
complete_all()which ignores the exclusive mode.Reported-by Sebastian Andrzej Siewior <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>Reviewed-by Greg Kroah-Hartman <[email protected]>Cc Kalle Valo <[email protected]>Cc "David S. Miller" <[email protected]>
Quoted 5 lines
---
V2: New patch to avoid conversion to swait functions later.--- drivers/net/wireless/intersil/orinoco/orinoco_usb.c | 21 ++++---------------- 1 file changed, 5 insertions(+), 16 deletions(-)
I assume this is going via some other than wireless-drivers so:
Signature · 1 line
https://wireless.wiki.kernel.org/en/developers/documentation/submittingpatches
PATCH v3 5/20 acpi: Remove header dependency
In reply to Thomas GleixnerFrom: Peter Zijlstra <[email protected]>
In order to avoid future header hell, remove the inclusion of proc_fs.h from acpi_bus.h. All it needs is a forward declaration of a struct.
--- drivers/platform/x86/dell-smo8800.c | 1 + drivers/platform/x86/wmi.c | 1 + drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c | 1 + include/acpi/acpi_bus.h | 2 +- 4 files changed, 4 insertions(+), 1 deletion(-)
drivers/platform/x86/dell-smo8800.c +1 -0
@@ -16,6 +16,7 @@#include <linux/interrupt.h> #include <linux/miscdevice.h> #include <linux/uaccess.h> +#include <linux/fs.h> struct smo8800_device {u32 irq;/* acpi device irq */
drivers/platform/x86/wmi.c +1 -0
@@ -29,6 +29,7 @@#include <linux/uaccess.h> #include <linux/uuid.h> #include <linux/wmi.h> +#include <linux/fs.h> #include <uapi/linux/wmi.h> ACPI_MODULE_NAME ("wmi" );
drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c +1 -0
@@ -19,6 +19,7 @@#include <linux/acpi.h> #include <linux/uaccess.h> #include <linux/miscdevice.h> +#include <linux/fs.h> #include "acpi_thermal_rel.h" static acpi_handle acpi_thermal_rel_handle;
include/acpi/acpi_bus.h +1 -1
@@ -80,7 +80,7 @@ bool acpi_dev_present(const char *hid, c#ifdef CONFIG_ACPI -#include <linux/proc_fs.h> +struct proc_dir_entry ;#define ACPI_BUS_FILE_ROOT "acpi"extern struct proc_dir_entry *acpi_root_dir;
Re: [patch V3 05/20] acpi: Remove header dependency
Quoted 7 lines · Thomas Gleixner
From: Peter Zijlstra <[email protected]>
In order to avoid future header hell, remove the inclusion of
proc_fs.hfromacpi_bus.h. All it needs is a forward declaration of a struct.
Quoted 61 lines
Signed-off-by Peter Zijlstra (Intel) <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>Cc Darren Hart <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Cc Zhang Rui <[email protected]>Cc "Rafael J. Wysocki" <[email protected]>Cc Len Brown <[email protected]>--- drivers/platform/x86/dell-smo8800.c | 1 + drivers/platform/x86/wmi.c | 1 + drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c | 1 + include/acpi/acpi_bus.h | 2 +- 4 files changed, 4 insertions(+), 1 deletion(-)drivers/platform/x86/dell-smo8800.c +1
-0@@ -16,6 +16,7 @@#include <linux/interrupt.h> #include <linux/miscdevice.h> #include <linux/uaccess.h> +#include <linux/fs.h> struct smo8800_device {u32 irq;/* acpi device irq */ drivers/platform/x86/wmi.c +1
-0@@ -29,6 +29,7 @@#include <linux/uaccess.h> #include <linux/uuid.h> #include <linux/wmi.h> +#include <linux/fs.h> #include <uapi/linux/wmi.h> ACPI_MODULE_NAME ("wmi" );drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c +1
-0@@ -19,6 +19,7 @@#include <linux/acpi.h> #include <linux/uaccess.h> #include <linux/miscdevice.h> +#include <linux/fs.h> #include "acpi_thermal_rel.h" static acpi_handle acpi_thermal_rel_handle;include/acpi/acpi_bus.h +1
-1@@ -80,7 +80,7 @@ bool acpi_dev_present(const char *hid, c#ifdef CONFIG_ACPI -#include <linux/proc_fs.h> +struct proc_dir_entry ;#define ACPI_BUS_FILE_ROOT "acpi"extern struct proc_dir_entry *acpi_root_dir;
Signature · 2 lines
With Best Regards, Andy Shevchenko
[tip: locking/core] acpi: Remove header dependency
In reply to Thomas GleixnerThe following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: df23e2be3d240b67222375062ce873f5ec84854d Gitweb: https://git.kernel.org/tip/df23e2be3d240b67222375062ce873f5ec84854d Author: Peter Zijlstra <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:49 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:21 +01:00
acpi: Remove header dependency
In order to avoid future header hell, remove the inclusion of proc_fs.h from acpi_bus.h. All it needs is a forward declaration of a struct.
--- drivers/platform/x86/dell-smo8800.c | 1 + drivers/platform/x86/wmi.c | 1 + drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c | 1 + include/acpi/acpi_bus.h | 2 +- 4 files changed, 4 insertions(+), 1 deletion(-)
drivers/platform/x86/dell-smo8800.c +1 -0
@@ -16,6 +16,7 @@#include <linux/interrupt.h> #include <linux/miscdevice.h> #include <linux/uaccess.h> +#include <linux/fs.h> struct smo8800_device {u32 irq;/* acpi device irq */
drivers/platform/x86/wmi.c +1 -0
@@ -29,6 +29,7 @@#include <linux/uaccess.h> #include <linux/uuid.h> #include <linux/wmi.h> +#include <linux/fs.h> #include <uapi/linux/wmi.h> ACPI_MODULE_NAME ("wmi" );
drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c +1 -0
@@ -19,6 +19,7 @@#include <linux/acpi.h> #include <linux/uaccess.h> #include <linux/miscdevice.h> +#include <linux/fs.h> #include "acpi_thermal_rel.h" static acpi_handle acpi_thermal_rel_handle;
include/acpi/acpi_bus.h +1 -1
@@ -80,7 +80,7 @@ bool acpi_dev_present(const char *hid, const char *uid, s64 hrv);#ifdef CONFIG_ACPI -#include <linux/proc_fs.h> +struct proc_dir_entry ;#define ACPI_BUS_FILE_ROOT "acpi"extern struct proc_dir_entry *acpi_root_dir;
Re: [patch V3 05/20] acpi: Remove header dependency
In reply to Thomas GleixnerQuoted 7 lines · Thomas Gleixner
From: Peter Zijlstra <[email protected]>
In order to avoid future header hell, remove the inclusion of
proc_fs.hfromacpi_bus.h. All it needs is a forward declaration of a struct.
Quoted 11 lines
Signed-off-by Peter Zijlstra (Intel) <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>Cc Darren Hart <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Cc Zhang Rui <[email protected]>Cc "Rafael J. Wysocki" <[email protected]>Cc Len Brown <[email protected]>
Quoted 50 lines
--- drivers/platform/x86/dell-smo8800.c | 1 + drivers/platform/x86/wmi.c | 1 + drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c | 1 + include/acpi/acpi_bus.h | 2 +- 4 files changed, 4 insertions(+), 1 deletion(-)drivers/platform/x86/dell-smo8800.c +1
-0@@ -16,6 +16,7 @@#include <linux/interrupt.h> #include <linux/miscdevice.h> #include <linux/uaccess.h> +#include <linux/fs.h> struct smo8800_device {u32 irq;/* acpi device irq */ drivers/platform/x86/wmi.c +1
-0@@ -29,6 +29,7 @@#include <linux/uaccess.h> #include <linux/uuid.h> #include <linux/wmi.h> +#include <linux/fs.h> #include <uapi/linux/wmi.h> ACPI_MODULE_NAME ("wmi" );drivers/thermal/intel/int340x_thermal/acpi_thermal_rel.c +1
-0@@ -19,6 +19,7 @@#include <linux/acpi.h> #include <linux/uaccess.h> #include <linux/miscdevice.h> +#include <linux/fs.h> #include "acpi_thermal_rel.h" static acpi_handle acpi_thermal_rel_handle;include/acpi/acpi_bus.h +1
-1@@ -80,7 +80,7 @@ bool acpi_dev_present(const char *hid, c#ifdef CONFIG_ACPI -#include <linux/proc_fs.h> +struct proc_dir_entry ;#define ACPI_BUS_FILE_ROOT "acpi"extern struct proc_dir_entry *acpi_root_dir;
PATCH v3 6/20 nds32: Remove mm.h from asm/uaccess.h
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/nds32/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
---
V3: New patch
--- arch/nds32/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)
arch/nds32/include/asm/uaccess.h +0 -1
@@ -11,7 +11,6 @@#include <asm/errno.h> #include <asm/memory.h> #include <asm/types.h> -#include <linux/mm.h> #define __asmeq (x, y) ".ifnc " x "," y " ; .err ; .endif\n\t"
Signature · 1 line
2.26.0.rc2
[tip: locking/core] nds32: Remove mm.h from asm/uaccess.h
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 43ea9d1a533a08dea4a2a9312d6aa2583313ef23 Gitweb: https://git.kernel.org/tip/43ea9d1a533a08dea4a2a9312d6aa2583313ef23 Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:50 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:21 +01:00
nds32: Remove mm.h from asm/uaccess.h
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/nds32/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
--- arch/nds32/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)
arch/nds32/include/asm/uaccess.h +0 -1
@@ -11,7 +11,6 @@#include <asm/errno.h> #include <asm/memory.h> #include <asm/types.h> -#include <linux/mm.h> #define __asmeq (x, y) ".ifnc " x "," y " ; .err ; .endif\n\t"
PATCH v3 7/20 csky: Remove mm.h from asm/uaccess.h
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/csky/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
---
V3: New patch
--- arch/csky/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)
arch/csky/include/asm/uaccess.h +0 -1
@@ -11,7 +11,6 @@#include <linux/errno.h> #include <linux/types.h> #include <linux/sched.h> -#include <linux/mm.h> #include <linux/string.h> #include <linux/version.h> #include <asm/segment.h>
Signature · 1 line
2.26.0.rc2
[tip: locking/core] csky: Remove mm.h from asm/uaccess.h
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: c5eedbae2f2b5d340e4f69d25b03ac5878e0efc7 Gitweb: https://git.kernel.org/tip/c5eedbae2f2b5d340e4f69d25b03ac5878e0efc7 Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:51 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:21 +01:00
csky: Remove mm.h from asm/uaccess.h
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/csky/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
--- arch/csky/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)
arch/csky/include/asm/uaccess.h +0 -1
@@ -11,7 +11,6 @@#include <linux/errno.h> #include <linux/types.h> #include <linux/sched.h> -#include <linux/mm.h> #include <linux/string.h> #include <linux/version.h> #include <asm/segment.h>
PATCH v3 8/20 hexagon: Remove mm.h from asm/uaccess.h
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/hexagon/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
---
V3: New patch
--- arch/hexagon/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)
arch/hexagon/include/asm/uaccess.h +0 -1
@@ -10,7 +10,6 @@/* * User space memory access functions */ -#include <linux/mm.h> #include <asm/sections.h> /*
Signature · 1 line
2.26.0.rc2
[tip: locking/core] hexagon: Remove mm.h from asm/uaccess.h
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 3f332aa0a7659789984f05f691a18df23b961fee Gitweb: https://git.kernel.org/tip/3f332aa0a7659789984f05f691a18df23b961fee Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:52 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:21 +01:00
hexagon: Remove mm.h from asm/uaccess.h
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/hexagon/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
--- arch/hexagon/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)
arch/hexagon/include/asm/uaccess.h +0 -1
@@ -10,7 +10,6 @@/* * User space memory access functions */ -#include <linux/mm.h> #include <asm/sections.h> /*
RE: [patch V3 08/20] hexagon: Remove mm.h from asm/uaccess.h
In reply to Thomas GleixnerQuoted 2 lines
-----Original Message-----
From: Thomas Gleixner <[email protected]>
...
Quoted 49 lines
Subject: [patch V3 08/20] hexagon: Remove
mm.hfromasm/uaccess.hFrom: Sebastian Andrzej Siewior <[email protected]>
The defconfig compiles without
linux/mm.h. Withmm.hincluded the include chain leands to:| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/hexagon/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type'struct
percpu_rw_semaphore'
| 1422 | structpercpu_rw_semaphorerw_sem[SB_FREEZE_LEVELS];once
rcuwait.hincludeslinux/sched/signal.h.Remove the
linux/mm.hinclude.Reported-by kbuild test robot <[email protected]>Signed-off-by Sebastian Andrzej Siewior <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>Cc Brian Cain <[email protected]>---
V3: New patch--- arch/hexagon/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)arch/hexagon/include/asm/uaccess.h +0
-2@@ -10,7 +10,6 @@/* * User space memory access functions */ -#include <linux/mm.h> #include <asm/sections.h> /* --
Quoted 2 lines
2.26.0.rc2
PATCH v3 9/20 ia64: Remove mm.h from asm/uaccess.h
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/ia64/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
---
V3: New patch
--- arch/ia64/include/asm/uaccess.h | 1 - arch/ia64/kernel/process.c | 1 + arch/ia64/mm/ioremap.c | 1 + 3 files changed, 2 insertions(+), 1 deletion(-)
arch/ia64/include/asm/uaccess.h +0 -1
@@ -35,7 +35,6 @@#include <linux/compiler.h> #include <linux/page-flags.h> -#include <linux/mm.h> #include <asm/intrinsics.h> #include <asm/pgtable.h>
arch/ia64/kernel/process.c +1 -0
@@ -681,3 +681,4 @@ machine_power_off (void)machine_halt (); } +EXPORT_SYMBOL (ia64_delay_loop);
arch/ia64/mm/ioremap.c +1 -0
@@ -8,6 +8,7 @@#include <linux/module.h> #include <linux/efi.h> #include <linux/io.h> +#include <linux/mm.h> #include <linux/vmalloc.h> #include <asm/io.h> #include <asm/meminit.h>
Signature · 1 line
2.26.0.rc2
[tip: locking/core] ia64: Remove mm.h from asm/uaccess.h
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 6f28b46c4f93b4b4632e8f598c4f796244851a58 Gitweb: https://git.kernel.org/tip/6f28b46c4f93b4b4632e8f598c4f796244851a58 Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:53 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:22 +01:00
ia64: Remove mm.h from asm/uaccess.h
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/ia64/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
--- arch/ia64/include/asm/uaccess.h | 1 - arch/ia64/kernel/process.c | 1 + arch/ia64/mm/ioremap.c | 1 + 3 files changed, 2 insertions(+), 1 deletion(-)
arch/ia64/include/asm/uaccess.h +0 -1
@@ -35,7 +35,6 @@#include <linux/compiler.h> #include <linux/page-flags.h> -#include <linux/mm.h> #include <asm/intrinsics.h> #include <asm/pgtable.h>
arch/ia64/kernel/process.c +1 -0
@@ -681,3 +681,4 @@ machine_power_off (void)machine_halt (); } +EXPORT_SYMBOL (ia64_delay_loop);
arch/ia64/mm/ioremap.c +1 -0
@@ -8,6 +8,7 @@#include <linux/module.h> #include <linux/efi.h> #include <linux/io.h> +#include <linux/mm.h> #include <linux/vmalloc.h> #include <asm/io.h> #include <asm/meminit.h>
PATCH v3 10/20 microblaze: Remove mm.h from asm/uaccess.h
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/microblaze/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
---
V3; New patch
--- arch/microblaze/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)
arch/microblaze/include/asm/uaccess.h +0 -1
@@ -12,7 +12,6 @@#define _ASM_MICROBLAZE_UACCESS_H#include <linux/kernel.h> -#include <linux/mm.h> #include <asm/mmu.h> #include <asm/page.h>
Signature · 1 line
2.26.0.rc2
[tip: locking/core] microblaze: Remove mm.h from asm/uaccess.h
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: d964ea7014a9d0d6312ccd5f47088a792371ad0b Gitweb: https://git.kernel.org/tip/d964ea7014a9d0d6312ccd5f47088a792371ad0b Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:54 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:22 +01:00
microblaze: Remove mm.h from asm/uaccess.h
The defconfig compiles without linux/mm.h. With mm.h included the include chain leands to:
| CC kernel/locking/percpu-rwsem.o | In file included from include/linux/huge_mm.h:8, | from include/linux/mm.h:567, | from arch/microblaze/include/asm/uaccess.h:, | from include/linux/uaccess.h:11, | from include/linux/sched/task.h:11, | from include/linux/sched/signal.h:9, | from include/linux/rcuwait.h:6, | from include/linux/percpu-rwsem.h:8, | from kernel/locking/percpu-rwsem.c:6: | include/linux/fs.h:1422:29: error: array type has incomplete element type 'struct percpu_rw_semaphore' | 1422 | struct percpu_rw_semaphore rw_sem[SB_FREEZE_LEVELS];
once rcuwait.h includes linux/sched/signal.h.
Remove the linux/mm.h include.
--- arch/microblaze/include/asm/uaccess.h | 1 - 1 file changed, 1 deletion(-)
arch/microblaze/include/asm/uaccess.h +0 -1
@@ -12,7 +12,6 @@#define _ASM_MICROBLAZE_UACCESS_H#include <linux/kernel.h> -#include <linux/mm.h> #include <asm/mmu.h> #include <asm/page.h>
PATCH v3 11/20 rcuwait: Add @state argument to rcuwait_wait_event()
In reply to Thomas GleixnerFrom: Peter Zijlstra (Intel) <[email protected]>
Extend rcuwait_wait_event() with a state variable so that it is not restricted to UNINTERRUPTIBLE waits.
--- include/linux/rcuwait.h | 12 ++++++++++-- kernel/locking/percpu-rwsem.c | 2 +- 2 files changed, 11 insertions(+), 3 deletions(-)
include/linux/rcuwait.h +10 -2
@@ -3,6 +3,7 @@#define _LINUX_RCUWAIT_H_#include <linux/rcupdate.h> +#include <linux/sched/signal.h> /* * rcuwait provides a way of blocking and waking up a single
@@ -30,23 +31,30 @@ extern void rcuwait_wake_up(struct rcuwa* The caller is responsible for locking around rcuwait_wait_event(), * such that writes to @task are properly serialized. */ -#define rcuwait_wait_event (w, condition) \ +#define rcuwait_wait_event (w, condition, state) \ ({ \ + int __ret = 0; \ rcu_assign_pointer((w)->task, current); \ for (;;) { \/* \ * Implicit barrier (A) pairs with (B) in \ * rcuwait_wake_up(). \ */ \ -set_current_state (TASK_UNINTERRUPTIBLE ); \ +set_current_state (state); \if (condition) \break ; \ \ +if (signal_pending_state (state, current)) { \ + __ret = -EINTR ; \ +break ; \ + } \ + \schedule (); \ } \ \WRITE_ONCE ((w)->task,NULL ); \__set_current_state (TASK_RUNNING ); \ + __ret; \ })#endif /* _LINUX_RCUWAIT_H_ */
kernel/locking/percpu-rwsem.c +1 -1
@@ -162,7 +162,7 @@ void percpu_down_write(struct percpu_rw_*/ /* Wait for all now active readers to complete. */ -rcuwait_wait_event (&sem->writer,readers_active_check (sem)); +rcuwait_wait_event (&sem->writer,readers_active_check (sem),TASK_UNINTERRUPTIBLE ); }EXPORT_SYMBOL_GPL (percpu_down_write);
[tip: locking/core] rcuwait: Add @state argument to rcuwait_wait_event()
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 80fbaf1c3f2926c834f8ca915441dfe27ce5487e Gitweb: https://git.kernel.org/tip/80fbaf1c3f2926c834f8ca915441dfe27ce5487e Author: Peter Zijlstra (Intel) <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:55 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:22 +01:00
rcuwait: Add @state argument to rcuwait_wait_event()
Extend rcuwait_wait_event() with a state variable so that it is not restricted to UNINTERRUPTIBLE waits.
--- include/linux/rcuwait.h | 12 ++++++++++-- kernel/locking/percpu-rwsem.c | 2 +- 2 files changed, 11 insertions(+), 3 deletions(-)
include/linux/rcuwait.h +10 -2
@@ -3,6 +3,7 @@#define _LINUX_RCUWAIT_H_#include <linux/rcupdate.h> +#include <linux/sched/signal.h> /* * rcuwait provides a way of blocking and waking up a single
@@ -30,23 +31,30 @@ extern void rcuwait_wake_up(struct rcuwait *w);* The caller is responsible for locking around rcuwait_wait_event(), * such that writes to @task are properly serialized. */ -#define rcuwait_wait_event (w, condition) \ +#define rcuwait_wait_event (w, condition, state) \ ({ \ + int __ret = 0; \ rcu_assign_pointer((w)->task, current); \ for (;;) { \/* \ * Implicit barrier (A) pairs with (B) in \ * rcuwait_wake_up(). \ */ \ -set_current_state (TASK_UNINTERRUPTIBLE ); \ +set_current_state (state); \if (condition) \break ; \ \ +if (signal_pending_state (state, current)) { \ + __ret = -EINTR ; \ +break ; \ + } \ + \schedule (); \ } \ \WRITE_ONCE ((w)->task,NULL ); \__set_current_state (TASK_RUNNING ); \ + __ret; \ })#endif /* _LINUX_RCUWAIT_H_ */
kernel/locking/percpu-rwsem.c +1 -1
@@ -234,7 +234,7 @@ void percpu_down_write(struct percpu_rw_semaphore *sem)*/ /* Wait for all active readers to complete. */ -rcuwait_wait_event (&sem->writer,readers_active_check (sem)); +rcuwait_wait_event (&sem->writer,readers_active_check (sem),TASK_UNINTERRUPTIBLE ); }EXPORT_SYMBOL_GPL (percpu_down_write);
PATCH v3 12/20 powerpc/ps3: Convert half completion to rcuwait
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
The PS3 notification interrupt and kthread use a hacked up completion to communicate. Since we're wanting to change the completion implementation and this is abuse anyway, replace it with a simple rcuwait since there is only ever the one waiter.
AFAICT the kthread uses TASK_INTERRUPTIBLE to not increase loadavg, kthreads cannot receive signals by default and this one doesn't look different. Use TASK_IDLE instead.
---
V3: Folded the init fix from bigeasy
V2: New patch to avoid the magic completion wait variant
--- arch/powerpc/platforms/ps3/device-init.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-)
arch/powerpc/platforms/ps3/device-init.c +9 -9
@@ -13,6 +13,7 @@#include <linux/init.h> #include <linux/slab.h> #include <linux/reboot.h> +#include <linux/rcuwait.h> #include <asm/firmware.h> #include <asm/lv1call.h>
@@ -670,7 +671,8 @@ struct ps3_notification_device {spinlock_t lock;u64 tag;u64 lv1_status; -struct completion done; +struct rcuwait wait; +bool done; };enum ps3_notify_type {
@@ -712,7 +714,8 @@ static irqreturn_t ps3_notification_intepr_debug ("%s:%u: completed, status 0x%llx\n" , __func__, __LINE__, status); dev->lv1_status = status; -complete (&dev->done); + dev->done = true; +rcuwait_wake_up (&dev->wait); }spin_unlock (&dev->lock);return IRQ_HANDLED ;
@@ -725,12 +728,12 @@ static int ps3_notification_read_write(sunsigned long flags;int res; -init_completion (&dev->done);spin_lock_irqsave (&dev->lock, flags); res = write ?lv1_storage_write (dev->sbd.dev_id,0 ,0 ,1 ,0 , lpar, &dev->tag) :lv1_storage_read (dev->sbd.dev_id,0 ,0 ,1 ,0 , lpar, &dev->tag); + dev->done = false;spin_unlock_irqrestore (&dev->lock, flags);if (res) {pr_err ("%s:%u: %s failed %d\n" , __func__, __LINE__, op, res);
@@ -738,14 +741,10 @@ static int ps3_notification_read_write(s }pr_debug ("%s:%u: notification %s issued\n" , __func__, __LINE__, op); - res =wait_event_interruptible (dev->done.wait, - dev->done.done ||kthread_should_stop ()); +rcuwait_wait_event (&dev->wait, dev->done ||kthread_should_stop (),TASK_IDLE ); +if (kthread_should_stop ()) res = -EINTR ; -if (res) { -pr_debug ("%s:%u: interrupted %s\n" , __func__, __LINE__, op); -return res; - }if (dev->lv1_status) { pr_err("%s:%u: %s not completed, status 0x%llx\n", __func__,
@@ -810,6 +809,7 @@ static int ps3_probe_thread(void *data) }spin_lock_init (&dev.lock); +rcuwait_init (&dev.wait); res =request_irq (irq, ps3_notification_interrupt,0 ,"ps3_notification" , &dev);
Re: [patch V3 12/20] powerpc/ps3: Convert half completion to rcuwait
Quoted 1 line · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
That's obviously bogus and wants to be:
From: Peter Zijlstra (Intel) <[email protected]>
[tip: locking/core] powerpc/ps3: Convert half completion to rcuwait
In reply to Thomas GleixnerThe following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: e21fee5368f46e211bc1f3cf118f2b122d644132 Gitweb: https://git.kernel.org/tip/e21fee5368f46e211bc1f3cf118f2b122d644132 Author: Peter Zijlstra (Intel) <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:56 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:22 +01:00
powerpc/ps3: Convert half completion to rcuwait
The PS3 notification interrupt and kthread use a hacked up completion to communicate. Since we're wanting to change the completion implementation and this is abuse anyway, replace it with a simple rcuwait since there is only ever the one waiter.
AFAICT the kthread uses TASK_INTERRUPTIBLE to not increase loadavg, kthreads cannot receive signals by default and this one doesn't look different. Use TASK_IDLE instead.
--- arch/powerpc/platforms/ps3/device-init.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-)
arch/powerpc/platforms/ps3/device-init.c +9 -9
@@ -13,6 +13,7 @@#include <linux/init.h> #include <linux/slab.h> #include <linux/reboot.h> +#include <linux/rcuwait.h> #include <asm/firmware.h> #include <asm/lv1call.h>
@@ -670,7 +671,8 @@ struct ps3_notification_device {spinlock_t lock;u64 tag;u64 lv1_status; -struct completion done; +struct rcuwait wait; +bool done; };enum ps3_notify_type {
@@ -712,7 +714,8 @@ static irqreturn_t ps3_notification_interrupt(int irq, void *data)pr_debug ("%s:%u: completed, status 0x%llx\n" , __func__, __LINE__, status); dev->lv1_status = status; -complete (&dev->done); + dev->done = true; +rcuwait_wake_up (&dev->wait); }spin_unlock (&dev->lock);return IRQ_HANDLED ;
@@ -725,12 +728,12 @@ static int ps3_notification_read_write(struct ps3_notification_device *dev,unsigned long flags;int res; -init_completion (&dev->done);spin_lock_irqsave (&dev->lock, flags); res = write ?lv1_storage_write (dev->sbd.dev_id,0 ,0 ,1 ,0 , lpar, &dev->tag) :lv1_storage_read (dev->sbd.dev_id,0 ,0 ,1 ,0 , lpar, &dev->tag); + dev->done = false;spin_unlock_irqrestore (&dev->lock, flags);if (res) {pr_err ("%s:%u: %s failed %d\n" , __func__, __LINE__, op, res);
@@ -738,14 +741,10 @@ static int ps3_notification_read_write(struct ps3_notification_device *dev, }pr_debug ("%s:%u: notification %s issued\n" , __func__, __LINE__, op); - res =wait_event_interruptible (dev->done.wait, - dev->done.done ||kthread_should_stop ()); +rcuwait_wait_event (&dev->wait, dev->done ||kthread_should_stop (),TASK_IDLE ); +if (kthread_should_stop ()) res = -EINTR ; -if (res) { -pr_debug ("%s:%u: interrupted %s\n" , __func__, __LINE__, op); -return res; - }if (dev->lv1_status) { pr_err("%s:%u: %s not completed, status 0x%llx\n", __func__,
@@ -810,6 +809,7 @@ static int ps3_probe_thread(void *data) }spin_lock_init (&dev.lock); +rcuwait_init (&dev.wait); res =request_irq (irq, ps3_notification_interrupt,0 ,"ps3_notification" , &dev);
Geoff Levand
maintainerRe: [patch V3 12/20] powerpc/ps3: Convert half completion to rcuwait
In reply to Thomas GleixnerHi,
Quoted 10 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
The PS3 notification interrupt and kthread use a hacked up completion to communicate. Since we're wanting to change the completion implementation and this is abuse anyway, replace it with a simple rcuwait since there is only ever the one waiter.
AFAICT the kthread uses
TASK_INTERRUPTIBLEto not increase loadavg, kthreads cannot receive signals by default and this one doesn't look different. UseTASK_IDLEinstead.
I tested the patch set applied against v5.6-rc7 on the PS3 and it worked as expected.
Tested by: Geoff Levand <[email protected]>
PATCH v3 13/20 Documentation: Add lock ordering and nesting documentation
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
The kernel provides a variety of locking primitives. The nesting of these lock types and the implications of them on RT enabled kernels is nowhere documented.
Add initial documentation.
---
V3: Addressed review comments from Paul, Jonathan, Davidlohr
V2: Addressed review comments from Randy
--- Documentation/locking/index.rst | 1 Documentation/locking/locktypes.rst | 299 ++++++++++++++++++++++++++++++++++++ 2 files changed, 300 insertions(+) create mode 100644 Documentation/locking/locktypes.rst
Documentation/locking/index.rst +1 -0
@@ -7,6 +7,7 @@ locking .. toctree:: :maxdepth: 1 + locktypes lockdep-design lockstat locktorture
Documentation/locking/locktypes.rst new file +299 -0
299 lines not on this page · raw message
[tip: locking/core] Documentation: Add lock ordering and nesting documentation
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 919e9e6395cfac23b7e71ed88930367459055daf Gitweb: https://git.kernel.org/tip/919e9e6395cfac23b7e71ed88930367459055daf Author: Thomas Gleixner <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:57 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:23 +01:00
Documentation: Add lock ordering and nesting documentation
The kernel provides a variety of locking primitives. The nesting of these lock types and the implications of them on RT enabled kernels is nowhere documented.
Add initial documentation.
--- Documentation/locking/index.rst | 1 +- Documentation/locking/locktypes.rst | 299 +++++++++++++++++++++++++++- 2 files changed, 300 insertions(+) create mode 100644 Documentation/locking/locktypes.rst
Documentation/locking/index.rst +1 -0
@@ -7,6 +7,7 @@ locking .. toctree:: :maxdepth: 1 + locktypes lockdep-design lockstat locktorture
Documentation/locking/locktypes.rst new file +299 -0
299 lines not on this page · raw message
Paul E. McKenney
maintainerRe: [patch V3 13/20] Documentation: Add lock ordering and nesting documentation
In reply to Thomas GleixnerDocumentation/locking/locktypes.rst
Quoted 35 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
The kernel provides a variety of locking primitives. The nesting of these lock types and the implications of them on RT enabled kernels is nowhere documented.
Add initial documentation.
Signed-off-by Thomas Gleixner <[email protected]>Cc "Paul E . McKenney" <[email protected]>Cc Jonathan Corbet <[email protected]>Cc Davidlohr Bueso <[email protected]>Cc Randy Dunlap <[email protected]>---
V3: Addressed review comments from Paul, Jonathan, Davidlohr
V2: Addressed review comments from Randy--- Documentation/locking/index.rst | 1 Documentation/locking/locktypes.rst | 299 ++++++++++++++++++++++++++++++++++++ 2 files changed, 300 insertions(+) create mode 100644 Documentation/locking/locktypes.rstDocumentation/locking/index.rst +1
-0@@ -7,6 +7,7 @@ locking .. toctree:: :maxdepth: 1 + locktypes lockdep-design lockstat locktortureDocumentation/locking/locktypes.rst new file +0
-0@@ -0,0 +1,299 @@
[ . . . Adding your example execution sequences . . . ]
Quoted 11 lines
Documentation/locking/locktypes.rst new file +11
-0+PREEMPT_RT kernels preserve all other spinlock_t semantics: + + - Tasks holding a spinlock_t do not migrate. Non-PREEMPT_RT kernels + avoid migration by disabling preemption. PREEMPT_RT kernels instead + disable migration, which ensures that pointers to per-CPU variables + remain valid even if the task is preempted. + + - Task state is preserved across spinlock acquisition, ensuring that the + task-state rules apply to all kernel configurations. Non-PREEMPT_RT + kernels leave task state untouched. However, PREEMPT_RT must change + task state if the task blocks during acquisition. Therefore, it saves
Documentation/locking/locktypes.rst line 151
Quoted 10 lines
Documentation/locking/locktypes.rst new file +10
-0+ the current task state before blocking and the corresponding lock wakeup + restores it. + + Other types of wakeups would normally unconditionally set the task state + to RUNNING, but that does not work here because the task must remain + blocked until the lock becomes available. Therefore, when a non-lock + wakeup attempts to awaken a task blocked waiting for a spinlock, it + instead sets the saved state to RUNNING. Then, when the lock + acquisition completes, the lock wakeup sets the task state to the saved + state, in this case setting it to RUNNING.
In the normal case where the task sleeps through the entire lock acquisition, the sequence of events is as follows:
state = UNINTERRUPTIBLE
lock()
block()
real_state = state
state = SLEEPONLOCK
lock wakeup
state = real_state == UNINTERRUPTIBLE
This sequence of events can occur when the task acquires spinlocks on its way to sleeping, for example, in a call to wait_event().
The non-lock wakeup can occur when a wakeup races with this wait_event(), which can result in the following sequence of events:
state = UNINTERRUPTIBLE
lock()
block()
real_state = state
state = SLEEPONLOCK
non lock wakeup
real_state = RUNNING
lock wakeup
state = real_state == RUNNING
Without this real_state subterfuge, the wakeup might be lost.
[ . . . and continuing where I left off earlier . . . ]
Quoted 4 lines
Documentation/locking/locktypes.rst new file +4
-0+bit spinlocks +------------- + +Bit spinlocks are problematic for PREEMPT_RT as they cannot be easily
Documentation/locking/locktypes.rst line 241
Quoted 10 lines
Documentation/locking/locktypes.rst new file +10
-0+substituted by an RT-mutex based implementation for obvious reasons. + +The semantics of bit spinlocks are preserved on PREEMPT_RT kernels and the +caveats vs. raw_spinlock_t apply. + +Some bit spinlocks are substituted by regular spinlock_t for PREEMPT_RT but +this requires conditional (#ifdef'ed) code changes at the usage site while +the spinlock_t substitution is simply done by the compiler and the +conditionals are restricted to header files and core implementation of the +locking primitives and the usage sites do not require any changes.
PREEMPT_RT cannot substitute bit spinlocks because a single bit is too small to accommodate an RT-mutex. Therefore, the semantics of bit spinlocks are preserved on PREEMPT_RT kernels, so that the raw_spinlock_t caveats also apply to bit spinlocks.
Some bit spinlocks are replaced with regular spinlock_t for PREEMPT_RT using conditional (#ifdef'ed) code changes at the usage site. In contrast, usage-site changes are not needed for the spinlock_t substitution. Instead, conditionals in header files and the core locking implemementation enable the compiler to do the substitution transparently.
Documentation/locking/locktypes.rst line 251
Quoted 8 lines
Documentation/locking/locktypes.rst new file +8
-0+Lock type nesting rules +======================= + +The most basic rules are: + + - Lock types of the same lock category (sleeping, spinning) can nest + arbitrarily as long as they respect the general lock ordering rules to + prevent deadlocks.
- Lock types in the same category (sleeping, spinning) can nest arbitrarily as long as they respect the general deadlock-avoidance ordering rules.
[ Give or take lockdep eventually complaining about too-deep nesting,
but that is probably not worth mentioning here. Leave that caveat to the lockdep documentation. ]
Documentation/locking/locktypes.rst line 257
Quoted 5 lines
Documentation/locking/locktypes.rst new file +5
-0+ - Sleeping lock types cannot nest inside spinning lock types. + + - Spinning lock types can nest inside sleeping lock types. + +These rules apply in general independent of CONFIG_PREEMPT_RT.
These constraints apply both in CONFIG_PREEMPT_RT and otherwise.
Documentation/locking/locktypes.rst line 263
Quoted 5 lines
Documentation/locking/locktypes.rst new file +5
-0+As PREEMPT_RT changes the lock category of spinlock_t and rwlock_t from +spinning to sleeping this has obviously restrictions how they can nest with +raw_spinlock_t. + +This results in the following nest ordering:
The fact that PREEMPT_RT changes the lock category of spinlock_t and rwlock_t from spinning to sleeping means that they cannot be acquired while holding a raw spinlock. This results in the following nesting ordering:
Documentation/locking/locktypes.rst line 269
Quoted 5 lines
Documentation/locking/locktypes.rst new file +5
-0+ 1) Sleeping locks + 2) spinlock_t and rwlock_t + 3) raw_spinlock_t and bit spinlocks + +Lockdep is aware of these constraints to ensure that they are respected.
Lockdep will complain if these constraints are violated, both in CONFIG_PREEMPT_RT and otherwise.
Documentation/locking/locktypes.rst line 276
Quoted 5 lines
Documentation/locking/locktypes.rst new file +5
-0+Owner semantics +=============== + +Most lock types in the Linux kernel have strict owner semantics, i.e. the +context (task) which acquires a lock has to release it.
The aforementioned lock types have strict owner semantics: The context (task) that acquired the lock must release it.
Documentation/locking/locktypes.rst line 287
Quoted 10 lines
Documentation/locking/locktypes.rst new file +10
-0+There are two exceptions: + + - semaphores + - rwsems + +semaphores have no owner semantics for historical reason, and as such +trylock and release operations can be called from any context. They are +often used for both serialization and waiting purposes. That's generally +discouraged and should be replaced by separate serialization and wait +mechanisms, such as mutexes and completions.
semaphores lack owner semantics for historical reasons, so their trylock and release operations may be called from any context. They are often used for both serialization and waiting, but new use cases should instead use separate serialization and wait mechanisms, such as mutexes and completions.
Documentation/locking/locktypes.rst line 299
Quoted 11 lines
Documentation/locking/locktypes.rst new file +11
-0+rwsems have grown interfaces which allow non owner release for special +purposes. This usage is problematic on PREEMPT_RT because PREEMPT_RT +substitutes all locking primitives except semaphores with RT-mutex based +implementations to provide priority inheritance for all lock types except +the truly spinning ones. Priority inheritance on ownerless locks is +obviously impossible. + +For now the rwsem non-owner release excludes code which utilizes it from +being used on PREEMPT_RT enabled kernels. In same cases this can be +mitigated by disabling portions of the code, in other cases the complete +functionality has to be disabled until a workable solution has been found.
rwsems have grown special-purpose interfaces that allow non-owner release. This non-owner release prevents PREEMPT_RT from substituting RT-mutex implementations, for example, by defeating priority inheritance. After all, if the lock has no owner, whose priority should be boosted? As a result, PREEMPT_RT does not currently support rwsem, which in turn means that code using it must therefore be disabled until a workable solution presents itself.
[ Note: Not as confident as I would like to be in the above. ]
Thanx, Paul
Re: [patch V3 13/20] Documentation: Add lock ordering and nesting documentation
Paul,
Quoted 25 lines · Paul E. McKenney
On Sat, Mar 21, 2020 at 12:25:57PM +0100, Thomas Gleixner wrote:
In the normal case where the task sleeps through the entire lock acquisition, the sequence of events is as follows:state = UNINTERRUPTIBLE
lock()
block()
real_state= state
state = SLEEPONLOCKlock wakeup
state =real_state== UNINTERRUPTIBLEThis sequence of events can occur when the task acquires spinlocks on its way to sleeping, for example, in a call to
wait_event().The non-lock wakeup can occur when a wakeup races with this
wait_event(), which can result in the following sequence of events:state = UNINTERRUPTIBLE
lock()
block()
real_state= state
state = SLEEPONLOCK
Quoted 7 lines
non lock wakeup
real_state= RUNNINGlock wakeup
state =real_state== RUNNINGWithout this
real_statesubterfuge, the wakeup might be lost.
I added this with a few modifications which reflect the actual implementation. Conceptually the same.
Quoted 9 lines
rwsems have grown special-purpose interfaces that allow non-owner release. This non-owner release prevents
PREEMPT_RTfrom substituting RT-mutex implementations, for example, by defeating priority inheritance. After all, if the lock has no owner, whose priority should be boosted? As a result,PREEMPT_RTdoes not currently support rwsem, which in turn means that code using it must therefore be disabled until a workable solution presents itself.[ Note: Not as confident as I would like to be in the above. ]
I'm not confident either especially not after looking at the actual code.
In fact I feel really stupid because the rw_semaphore reader non-owner restriction on RT simply does not exist anymore and my history biased memory tricked me.
The first rw_semaphore implementation of RT was simple and restricted the reader side to a single reader to support PI on both the reader and the writer side. That obviosuly did not scale well and made mmap_sem heavy use cases pretty unhappy.
The short interlude with multi-reader boosting turned out to be a failed experiment - Steven might still disagree though :)
At some point we gave up and I myself (sic!) reimplemented the RT variant of rw_semaphore with a reader biased mechanism.
The reader never holds the underlying rt_mutex accross the read side critical section. It merily increments the reader count and drops it on release.
The only time a reader takes the rt_mutex is when it blocks on a writer. Writers hold the rt_mutex across the write side critical section to allow incoming readers to boost them. Once the writer releases the rw_semaphore it unlocks the rt_mutex which is then handed off to the readers. They increment the reader count and then drop the rt_mutex before continuing in the read side critical section.
So while I changed the implementation it did obviously not occur to me that this also lifted the non-owner release restriction. Nobody else noticed either. So we kept dragging this along in both memory and implementation. Both will be fixed now :)
The owner semantics of down/up_read() are only enforced by lockdep. That applies to both RT and !RT. The up/down_read_non_owner() variants are just there to tell lockdep about it.
So, I picked up your other suggestions with slight modifications and adjusted the owner, semaphore and rw_semaphore docs accordingly.
Please have a close look at the patch below (applies on tip core/locking).
Thanks,
tglx, who is searching a brown paperbag
8<----------
Documentation/locking/locktypes.rst | 148 +++++++++++++++++++++++------------- 1 file changed, 98 insertions(+), 50 deletions(-)
Documentation/locking/locktypes.rst +98 -50
@@ -67,6 +67,17 @@ Spinning locks implicitly disable preemp _irqsave/restore() Save and disable / restore interrupt disabled state =================== ==================================================== +Owner semantics +=============== + +The aforementioned lock types except semaphores have strict owner +semantics: + + The context (task) that acquired the lock must release it. + +rw_semaphores have a special interface which allows non-owner release for +readers. + rtmutex =======
@@ -83,6 +94,51 @@ interrupt handlers and soft interrupts. and rwlock_t to be implemented via RT-mutexes. +sempahore +========= + +semaphore is a counting semaphore implementation. + +Semaphores are often used for both serialization and waiting, but new use +cases should instead use separate serialization and wait mechanisms, such +as mutexes and completions. + +sempahores and PREEMPT_RT +---------------------------- + +PREEMPT_RT does not change the sempahore implementation. That's impossible +due to the counting semaphore semantics which have no concept of owners. +The lack of an owner conflicts with priority inheritance. After all an +unknown owner cannot be boosted. As a consequence blocking on semaphores +can be subject to priority inversion. + + +rw_sempahore +============ + +rw_semaphore is a multiple readers and single writer lock mechanism. + +On non-PREEMPT_RT kernels the implementation is fair, thus preventing +writer starvation. + +rw_semaphore complies by default with the strict owner semantics, but there +exist special-purpose interfaces that allow non-owner release for readers. +These work independent of the kernel configuration. + +rw_sempahore and PREEMPT_RT +--------------------------- + +PREEMPT_RT kernels map rw_sempahore to a separate rt_mutex-based +implementation, thus changing the fairness: + + Because an rw_sempaphore writer cannot grant its priority to multiple + readers, a preempted low-priority reader will continue holding its lock, + thus starving even high-priority writers. In contrast, because readers + can grant their priority to a writer, a preempted low-priority writer will + have its priority boosted until it releases the lock, thus preventing that + writer from starving readers. + + raw_spinlock_t and spinlock_t =============================
@@ -140,7 +196,16 @@ On a PREEMPT_RT enabled kernel spinlock_ kernels leave task state untouched. However, PREEMPT_RT must change task state if the task blocks during acquisition. Therefore, it saves the current task state before blocking and the corresponding lock wakeup - restores it. + restores it:: + + task->state = TASK_INTERRUPTIBLE + lock() + block() + task->saved_state = task->state + task->state = TASK_UNINTERRUPTIBLE + schedule() + lock wakeup + task->state = task->saved_state Other types of wakeups would normally unconditionally set the task state to RUNNING, but that does not work here because the task must remain
@@ -148,7 +213,22 @@ On a PREEMPT_RT enabled kernel spinlock_ wakeup attempts to awaken a task blocked waiting for a spinlock, it instead sets the saved state to RUNNING. Then, when the lock acquisition completes, the lock wakeup sets the task state to the saved - state, in this case setting it to RUNNING. + state, in this case setting it to RUNNING:: + + task->state = TASK_INTERRUPTIBLE + lock() + block() + task->saved_state = task->state + task->state = TASK_UNINTERRUPTIBLE + schedule() + non lock wakeup + task->saved_state = TASK_RUNNING + + lock wakeup + task->state = task->saved_state + + This ensures that the real wakeup cannot be lost. + rwlock_t ========
@@ -228,17 +308,16 @@ while holding normal non-raw spinlocks b bit spinlocks ------------- -Bit spinlocks are problematic for PREEMPT_RT as they cannot be easily -substituted by an RT-mutex based implementation for obvious reasons. - -The semantics of bit spinlocks are preserved on PREEMPT_RT kernels and the -caveats vs. raw_spinlock_t apply. - -Some bit spinlocks are substituted by regular spinlock_t for PREEMPT_RT but -this requires conditional (#ifdef'ed) code changes at the usage site while -the spinlock_t substitution is simply done by the compiler and the -conditionals are restricted to header files and core implementation of the -locking primitives and the usage sites do not require any changes. +PREEMPT_RT cannot substitute bit spinlocks because a single bit is too +small to accommodate an RT-mutex. Therefore, the semantics of bit +spinlocks are preserved on PREEMPT_RT kernels, so that the raw_spinlock_t +caveats also apply to bit spinlocks. + +Some bit spinlocks are replaced with regular spinlock_t for PREEMPT_RT +using conditional (#ifdef'ed) code changes at the usage site. In contrast, +usage-site changes are not needed for the spinlock_t substitution. +Instead, conditionals in header files and the core locking implemementation +enable the compiler to do the substitution transparently. Lock type nesting rules
@@ -254,46 +333,15 @@ Lock type nesting rules - Spinning lock types can nest inside sleeping lock types. -These rules apply in general independent of CONFIG_PREEMPT_RT. +These constraints apply both in CONFIG_PREEMPT_RT and otherwise. -As PREEMPT_RT changes the lock category of spinlock_t and rwlock_t from -spinning to sleeping this has obviously restrictions how they can nest with -raw_spinlock_t. - -This results in the following nest ordering: +The fact that PREEMPT_RT changes the lock category of spinlock_t and +rwlock_t from spinning to sleeping means that they cannot be acquired while +holding a raw spinlock. This results in the following nesting ordering: 1) Sleeping locks 2) spinlock_t and rwlock_t 3) raw_spinlock_t and bit spinlocks -Lockdep is aware of these constraints to ensure that they are respected. - - -Owner semantics -=============== - -Most lock types in the Linux kernel have strict owner semantics, i.e. the -context (task) which acquires a lock has to release it. - -There are two exceptions: - - - semaphores - - rwsems - -semaphores have no owner semantics for historical reason, and as such -trylock and release operations can be called from any context. They are -often used for both serialization and waiting purposes. That's generally -discouraged and should be replaced by separate serialization and wait -mechanisms, such as mutexes and completions. - -rwsems have grown interfaces which allow non owner release for special -purposes. This usage is problematic on PREEMPT_RT because PREEMPT_RT -substitutes all locking primitives except semaphores with RT-mutex based -implementations to provide priority inheritance for all lock types except -the truly spinning ones. Priority inheritance on ownerless locks is -obviously impossible. - -For now the rwsem non-owner release excludes code which utilizes it from -being used on PREEMPT_RT enabled kernels. In same cases this can be -mitigated by disabling portions of the code, in other cases the complete -functionality has to be disabled until a workable solution has been found. +Lockdep will complain if these constraints are violated, both in +CONFIG_PREEMPT_RT and otherwise.
Paul E. McKenney
maintainerRe: [patch V3 13/20] Documentation: Add lock ordering and nesting documentation
Quoted 31 lines · Thomas Gleixner
Paul,
Quoted 28 lines · Paul E. McKenney
On Sat, Mar 21, 2020 at 12:25:57PM +0100, Thomas Gleixner wrote:
In the normal case where the task sleeps through the entire lock acquisition, the sequence of events is as follows:state = UNINTERRUPTIBLE
lock()
block()
real_state= state
state = SLEEPONLOCKlock wakeup
state =real_state== UNINTERRUPTIBLEThis sequence of events can occur when the task acquires spinlocks on its way to sleeping, for example, in a call to
wait_event().The non-lock wakeup can occur when a wakeup races with this
wait_event(), which can result in the following sequence of events:state = UNINTERRUPTIBLE
lock()
block()
real_state= state
state = SLEEPONLOCKnon lock wakeup
real_state= RUNNING
Quoted 7 lines
Quoted 4 lines
lock wakeup state = real_state == RUNNINGWithout this
real_statesubterfuge, the wakeup might be lost.I added this with a few modifications which reflect the actual implementation. Conceptually the same.
Looks good!
Quoted 8 lines
Quoted 8 lines
rwsems have grown special-purpose interfaces that allow non-owner release. This non-owner release prevents
PREEMPT_RTfrom substituting RT-mutex implementations, for example, by defeating priority inheritance. After all, if the lock has no owner, whose priority should be boosted? As a result,PREEMPT_RTdoes not currently support rwsem, which in turn means that code using it must therefore be disabled until a workable solution presents itself.
Quoted 8 lines
Quoted 1 line
[ Note: Not as confident as I would like to be in the above. ]
I'm not confident either especially not after looking at the actual code.
In fact I feel really stupid because the
rw_semaphorereader non-owner restriction on RT simply does not exist anymore and my history biased memory tricked me.
I guess I am glad that it is not just me. ;-)
Quoted 31 lines
The first
rw_semaphoreimplementation of RT was simple and restricted the reader side to a single reader to support PI on both the reader and the writer side. That obviosuly did not scale well and mademmap_semheavy use cases pretty unhappy.The short interlude with multi-reader boosting turned out to be a failed experiment - Steven might still disagree though :)
At some point we gave up and I myself (sic!) reimplemented the RT variant of
rw_semaphorewith a reader biased mechanism.The reader never holds the underlying
rt_mutexaccross the read side critical section. It merily increments the reader count and drops it on release.The only time a reader takes the
rt_mutexis when it blocks on a writer. Writers hold thert_mutexacross the write side critical section to allow incoming readers to boost them. Once the writer releases therw_semaphoreit unlocks thert_mutexwhich is then handed off to the readers. They increment the reader count and then drop thert_mutexbefore continuing in the read side critical section.So while I changed the implementation it did obviously not occur to me that this also lifted the non-owner release restriction. Nobody else noticed either. So we kept dragging this along in both memory and implementation. Both will be fixed now :)
The owner semantics of down/up_read() are only enforced by lockdep. That applies to both RT and !RT. The up/down_read_non_owner() variants are just there to tell lockdep about it.
Quoted 8 lines
So, I picked up your other suggestions with slight modifications and adjusted the owner, semaphore and
rw_semaphoredocs accordingly.Please have a close look at the patch below (applies on tip core/locking).
Thanks,
tglx, who is searching a brown paperbag
Sorry, used all the ones here over the past few days. :-/
Please see below for a wordsmithing patch to be applied on top of or merged into the patch in your email.
Thanx, Paul
------------------------------------------------------------------------
commit e38c64ce8db45e2b0a19082f1e1f988c3b25fb81
Author: Paul E. McKenney <[email protected]> Date: Tue Mar 24 17:23:36 2020 -0700
Documentation: Wordsmith lock ordering and nesting documentation
This commit is strictly wordsmithing with no (intended) semantic changes.
Documentation/locking/locktypes.rst +15 -15
@@ -94,7 +94,7 @@ interrupt handlers and soft interrupts. This conversion allows spinlock_t and rwlock_t to be implemented via RT-mutexes. -sempahore +semaphore ========= semaphore is a counting semaphore implementation.
@@ -103,17 +103,17 @@ Semaphores are often used for both serialization and waiting, but new use cases should instead use separate serialization and wait mechanisms, such as mutexes and completions. -sempahores and PREEMPT_RT +semaphores and PREEMPT_RT ---------------------------- -PREEMPT_RT does not change the sempahore implementation. That's impossible -due to the counting semaphore semantics which have no concept of owners. -The lack of an owner conflicts with priority inheritance. After all an -unknown owner cannot be boosted. As a consequence blocking on semaphores -can be subject to priority inversion. +PREEMPT_RT does not change the semaphore implementation because counting +semaphores have no concept of owners, thus preventing PREEMPT_RT from +providing priority inheritance for semaphores. After all, an unknown +owner cannot be boosted. As a consequence, blocking on semaphores can +result in priority inversion. -rw_sempahore +rw_semaphore ============ rw_semaphore is a multiple readers and single writer lock mechanism.
@@ -125,13 +125,13 @@ rw_semaphore complies by default with the strict owner semantics, but there exist special-purpose interfaces that allow non-owner release for readers. These work independent of the kernel configuration. -rw_sempahore and PREEMPT_RT +rw_semaphore and PREEMPT_RT --------------------------- -PREEMPT_RT kernels map rw_sempahore to a separate rt_mutex-based +PREEMPT_RT kernels map rw_semaphore to a separate rt_mutex-based implementation, thus changing the fairness: - Because an rw_sempaphore writer cannot grant its priority to multiple + Because an rw_semaphore writer cannot grant its priority to multiple readers, a preempted low-priority reader will continue holding its lock, thus starving even high-priority writers. In contrast, because readers can grant their priority to a writer, a preempted low-priority writer will
@@ -158,7 +158,7 @@ critical section is tiny, thus avoiding RT-mutex overhead. spinlock_t ---------- -The semantics of spinlock_t change with the state of CONFIG_PREEMPT_RT. +The semantics of spinlock_t change with the state of PREEMPT_RT. On a non PREEMPT_RT enabled kernel spinlock_t is mapped to raw_spinlock_t and has exactly the same semantics.
@@ -196,7 +196,7 @@ PREEMPT_RT kernels preserve all other spinlock_t semantics: kernels leave task state untouched. However, PREEMPT_RT must change task state if the task blocks during acquisition. Therefore, it saves the current task state before blocking and the corresponding lock wakeup - restores it:: + restores it, as shown below:: task->state = TASK_INTERRUPTIBLE lock()
@@ -333,7 +333,7 @@ The most basic rules are: - Spinning lock types can nest inside sleeping lock types. -These constraints apply both in CONFIG_PREEMPT_RT and otherwise. +These constraints apply both in PREEMPT_RT and otherwise. The fact that PREEMPT_RT changes the lock category of spinlock_t and rwlock_t from spinning to sleeping means that they cannot be acquired while
@@ -344,4 +344,4 @@ holding a raw spinlock. This results in the following nesting ordering: 3) raw_spinlock_t and bit spinlocks Lockdep will complain if these constraints are violated, both in -CONFIG_PREEMPT_RT and otherwise. +PREEMPT_RT and otherwise.
Documentation/locking/locktypes: Further clarifications and wordsmithing
The documentation of rw_semaphores is wrong as it claims that the non-owner reader release is not supported by RT. That's just history biased memory distortion.
Split the 'Owner semantics' section up and add separate sections for semaphore and rw_semaphore to reflect reality.
Aside of that the following updates are done:
- Add pseudo code to document the spinlock state preserving mechanism on PREEMPT_RT
- Wordsmith the bitspinlock and lock nesting sections
--- Documentation/locking/locktypes.rst | 150 +++++++++++++++++++++++------------- 1 file changed, 99 insertions(+), 51 deletions(-)
Documentation/locking/locktypes.rst +99 -51
@@ -67,6 +67,17 @@ Spinning locks implicitly disable preemp _irqsave/restore() Save and disable / restore interrupt disabled state =================== ==================================================== +Owner semantics +=============== + +The aforementioned lock types except semaphores have strict owner +semantics: + + The context (task) that acquired the lock must release it. + +rw_semaphores have a special interface which allows non-owner release for +readers. + rtmutex =======
@@ -83,6 +94,51 @@ interrupt handlers and soft interrupts. and rwlock_t to be implemented via RT-mutexes. +semaphore +========= + +semaphore is a counting semaphore implementation. + +Semaphores are often used for both serialization and waiting, but new use +cases should instead use separate serialization and wait mechanisms, such +as mutexes and completions. + +semaphores and PREEMPT_RT +---------------------------- + +PREEMPT_RT does not change the semaphore implementation because counting +semaphores have no concept of owners, thus preventing PREEMPT_RT from +providing priority inheritance for semaphores. After all, an unknown +owner cannot be boosted. As a consequence, blocking on semaphores can +result in priority inversion. + + +rw_semaphore +============ + +rw_semaphore is a multiple readers and single writer lock mechanism. + +On non-PREEMPT_RT kernels the implementation is fair, thus preventing +writer starvation. + +rw_semaphore complies by default with the strict owner semantics, but there +exist special-purpose interfaces that allow non-owner release for readers. +These work independent of the kernel configuration. + +rw_semaphore and PREEMPT_RT +--------------------------- + +PREEMPT_RT kernels map rw_semaphore to a separate rt_mutex-based +implementation, thus changing the fairness: + + Because an rw_semaphore writer cannot grant its priority to multiple + readers, a preempted low-priority reader will continue holding its lock, + thus starving even high-priority writers. In contrast, because readers + can grant their priority to a writer, a preempted low-priority writer will + have its priority boosted until it releases the lock, thus preventing that + writer from starving readers. + + raw_spinlock_t and spinlock_t =============================
@@ -102,7 +158,7 @@ critical section is tiny, thus avoiding spinlock_t ---------- -The semantics of spinlock_t change with the state of CONFIG_PREEMPT_RT. +The semantics of spinlock_t change with the state of PREEMPT_RT. On a non PREEMPT_RT enabled kernel spinlock_t is mapped to raw_spinlock_t and has exactly the same semantics.
@@ -140,7 +196,16 @@ On a PREEMPT_RT enabled kernel spinlock_ kernels leave task state untouched. However, PREEMPT_RT must change task state if the task blocks during acquisition. Therefore, it saves the current task state before blocking and the corresponding lock wakeup - restores it. + restores it, as shown below:: + + task->state = TASK_INTERRUPTIBLE + lock() + block() + task->saved_state = task->state + task->state = TASK_UNINTERRUPTIBLE + schedule() + lock wakeup + task->state = task->saved_state Other types of wakeups would normally unconditionally set the task state to RUNNING, but that does not work here because the task must remain
@@ -148,7 +213,22 @@ On a PREEMPT_RT enabled kernel spinlock_ wakeup attempts to awaken a task blocked waiting for a spinlock, it instead sets the saved state to RUNNING. Then, when the lock acquisition completes, the lock wakeup sets the task state to the saved - state, in this case setting it to RUNNING. + state, in this case setting it to RUNNING:: + + task->state = TASK_INTERRUPTIBLE + lock() + block() + task->saved_state = task->state + task->state = TASK_UNINTERRUPTIBLE + schedule() + non lock wakeup + task->saved_state = TASK_RUNNING + + lock wakeup + task->state = task->saved_state + + This ensures that the real wakeup cannot be lost. + rwlock_t ========
@@ -228,17 +308,16 @@ while holding normal non-raw spinlocks b bit spinlocks ------------- -Bit spinlocks are problematic for PREEMPT_RT as they cannot be easily -substituted by an RT-mutex based implementation for obvious reasons. - -The semantics of bit spinlocks are preserved on PREEMPT_RT kernels and the -caveats vs. raw_spinlock_t apply. - -Some bit spinlocks are substituted by regular spinlock_t for PREEMPT_RT but -this requires conditional (#ifdef'ed) code changes at the usage site while -the spinlock_t substitution is simply done by the compiler and the -conditionals are restricted to header files and core implementation of the -locking primitives and the usage sites do not require any changes. +PREEMPT_RT cannot substitute bit spinlocks because a single bit is too +small to accommodate an RT-mutex. Therefore, the semantics of bit +spinlocks are preserved on PREEMPT_RT kernels, so that the raw_spinlock_t +caveats also apply to bit spinlocks. + +Some bit spinlocks are replaced with regular spinlock_t for PREEMPT_RT +using conditional (#ifdef'ed) code changes at the usage site. In contrast, +usage-site changes are not needed for the spinlock_t substitution. +Instead, conditionals in header files and the core locking implemementation +enable the compiler to do the substitution transparently. Lock type nesting rules
@@ -254,46 +333,15 @@ Lock type nesting rules - Spinning lock types can nest inside sleeping lock types. -These rules apply in general independent of CONFIG_PREEMPT_RT. +These constraints apply both in PREEMPT_RT and otherwise. -As PREEMPT_RT changes the lock category of spinlock_t and rwlock_t from -spinning to sleeping this has obviously restrictions how they can nest with -raw_spinlock_t. - -This results in the following nest ordering: +The fact that PREEMPT_RT changes the lock category of spinlock_t and +rwlock_t from spinning to sleeping means that they cannot be acquired while +holding a raw spinlock. This results in the following nesting ordering: 1) Sleeping locks 2) spinlock_t and rwlock_t 3) raw_spinlock_t and bit spinlocks -Lockdep is aware of these constraints to ensure that they are respected. - - -Owner semantics -=============== - -Most lock types in the Linux kernel have strict owner semantics, i.e. the -context (task) which acquires a lock has to release it. - -There are two exceptions: - - - semaphores - - rwsems - -semaphores have no owner semantics for historical reason, and as such -trylock and release operations can be called from any context. They are -often used for both serialization and waiting purposes. That's generally -discouraged and should be replaced by separate serialization and wait -mechanisms, such as mutexes and completions. - -rwsems have grown interfaces which allow non owner release for special -purposes. This usage is problematic on PREEMPT_RT because PREEMPT_RT -substitutes all locking primitives except semaphores with RT-mutex based -implementations to provide priority inheritance for all lock types except -the truly spinning ones. Priority inheritance on ownerless locks is -obviously impossible. - -For now the rwsem non-owner release excludes code which utilizes it from -being used on PREEMPT_RT enabled kernels. In same cases this can be -mitigated by disabling portions of the code, in other cases the complete -functionality has to be disabled until a workable solution has been found. +Lockdep will complain if these constraints are violated, both in +PREEMPT_RT and otherwise.
Sebastian Siewior
Acked-byRe: Documentation/locking/locktypes: Further clarifications and wordsmithing
Quoted 9 lines · Thomas Gleixner
The documentation of
rw_semaphoresis wrong as it claims that the non-owner reader release is not supported by RT. That's just history biased memory distortion.Split the 'Owner semantics' section up and add separate sections for semaphore and
rw_semaphoreto reflect reality.Aside of that the following updates are done:
Quoted 8 lines
- Add pseudo code to document the spinlock state preserving mechanism on
PREEMPT_RT- Wordsmith the bitspinlock and lock nesting sections
Co-developed-by Paul McKenney <[email protected]>Signed-off-by Paul McKenney <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>
Quoted 2 lines
Documentation/locking/locktypes.rst +0
-0
…
Documentation/locking/locktypes.rst interrupt handlers and soft interrupts. · line 126
Quoted 11 lines
Documentation/locking/locktypes.rst +11
-0+rw_semaphore +============ + +rw_semaphore is a multiple readers and single writer lock mechanism. + +On non-PREEMPT_RT kernels the implementation is fair, thus preventing +writer starvation. + +rw_semaphore complies by default with the strict owner semantics, but there +exist special-purpose interfaces that allow non-owner release for readers. +These work independent of the kernel configuration.
This reads funny, could be my English. "This works independent …" maybe?
Sebastian
Paul E. McKenney
maintainerRe: Documentation/locking/locktypes: Further clarifications and wordsmithing
Quoted 23 lines · Sebastian Siewior
Quoted 9 lines · Thomas Gleixner
The documentation of
rw_semaphoresis wrong as it claims that the non-owner reader release is not supported by RT. That's just history biased memory distortion.Split the 'Owner semantics' section up and add separate sections for semaphore and
rw_semaphoreto reflect reality.Aside of that the following updates are done:
Quoted 8 lines
- Add pseudo code to document the spinlock state preserving mechanism on
PREEMPT_RT- Wordsmith the bitspinlock and lock nesting sections
Co-developed-by Paul McKenney <[email protected]>Signed-off-by Paul McKenney <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>Quoted 2 lines
Documentation/locking/locktypes.rst +0
-0…
Quoted 13 lines
Documentation/locking/locktypes.rst interrupt handlers and soft interrupts. · line 126
Quoted 11 lines
Documentation/locking/locktypes.rst +11
-0+rw_semaphore +============ + +rw_semaphore is a multiple readers and single writer lock mechanism. + +On non-PREEMPT_RT kernels the implementation is fair, thus preventing +writer starvation. + +rw_semaphore complies by default with the strict owner semantics, but there +exist special-purpose interfaces that allow non-owner release for readers. +These work independent of the kernel configuration.This reads funny, could be my English. "This works independent …" maybe?
The "These" refers to "interfaces", which is plural, so "These" rather than "This". But yes, it is a bit awkward, because you have to skip back past "readers", "release", and "non-owner" to find the implied subject of that last sentence.
So how about this instead, making the implied subject explicit?
rw_semaphore complies by default with the strict owner semantics, but there exist special-purpose interfaces that allow non-owner release for readers. These interfaces work independent of the kernel configuration.
Thanx, Paul
Re: Documentation/locking/locktypes: Further clarifications and wordsmithing
Quoted 22 lines · Paul E. McKenney
Quoted 16 lines
Quoted 2 lines
Documentation/locking/locktypes.rst +0
-0…
Documentation/locking/locktypes.rst interrupt handlers and soft interrupts. · line 126
Quoted 11 lines
Documentation/locking/locktypes.rst +11
-0+rw_semaphore +============ + +rw_semaphore is a multiple readers and single writer lock mechanism. + +On non-PREEMPT_RT kernels the implementation is fair, thus preventing +writer starvation. + +rw_semaphore complies by default with the strict owner semantics, but there +exist special-purpose interfaces that allow non-owner release for readers. +These work independent of the kernel configuration.This reads funny, could be my English. "This works independent …" maybe?
The "These" refers to "interfaces", which is plural, so "These" rather than "This". But yes, it is a bit awkward, because you have to skip back past "readers", "release", and "non-owner" to find the implied subject of that last sentence.
Quoted 5 lines
So how about this instead, making the implied subject explicit?
rw_semaphorecomplies by default with the strict owner semantics, but there exist special-purpose interfaces that allow non-owner release for readers. These interfaces work independent of the kernel configuration.
Yes, perfect. Thank you.
Quoted 1 line
Thanx, Paul
Sebastian
Randy Dunlap
reviewerPATCH v2 1/1 Documentation/locking/locktypes: minor copy editor fixes
In reply to Thomas GleixnerFrom: Randy Dunlap <[email protected]>
Minor editorial fixes:
- add some hyphens in multi-word adjectives
- add some periods for consistency
- add "'" for possessive CPU's
- capitalize IRQ when it's an acronym and not part of a function name
--- Documentation/locking/locktypes.rst | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
Documentation/locking/locktypes.rst +8 -8
@@ -84,7 +84,7 @@ rtmutex RT-mutexes are mutexes with support for priority inheritance (PI). -PI has limitations on non PREEMPT_RT enabled kernels due to preemption and +PI has limitations on non-PREEMPT_RT-enabled kernels due to preemption and interrupt disabled sections. PI clearly cannot preempt preemption-disabled or interrupt-disabled
@@ -150,7 +150,7 @@ kernel configuration including PREEMPT_R raw_spinlock_t is a strict spinning lock implementation in all kernels, including PREEMPT_RT kernels. Use raw_spinlock_t only in real critical -core code, low level interrupt handling and places where disabling +core code, low-level interrupt handling and places where disabling preemption or interrupts is required, for example, to safely access hardware state. raw_spinlock_t can sometimes also be used when the critical section is tiny, thus avoiding RT-mutex overhead.
@@ -160,20 +160,20 @@ spinlock_t The semantics of spinlock_t change with the state of PREEMPT_RT. -On a non PREEMPT_RT enabled kernel spinlock_t is mapped to raw_spinlock_t +On a non-PREEMPT_RT-enabled kernel spinlock_t is mapped to raw_spinlock_t and has exactly the same semantics. spinlock_t and PREEMPT_RT ------------------------- -On a PREEMPT_RT enabled kernel spinlock_t is mapped to a separate +On a PREEMPT_RT-enabled kernel spinlock_t is mapped to a separate implementation based on rt_mutex which changes the semantics: - - Preemption is not disabled + - Preemption is not disabled. - The hard interrupt related suffixes for spin_lock / spin_unlock - operations (_irq, _irqsave / _irqrestore) do not affect the CPUs - interrupt disabled state + operations (_irq, _irqsave / _irqrestore) do not affect the CPU's + interrupt disabled state. - The soft interrupt related suffix (_bh()) still disables softirq handlers.
@@ -279,7 +279,7 @@ fully preemptible context. Instead, use spin_lock_irqsave() and their unlock counterparts. In cases where the interrupt disabling and locking must remain separate, PREEMPT_RT offers a local_lock mechanism. Acquiring the local_lock pins the task to a CPU, -allowing things like per-CPU irq-disabled locks to be acquired. However, +allowing things like per-CPU IRQ-disabled locks to be acquired. However, this approach should be used only where absolutely necessary.
Re: [PATCH v2] Documentation/locking/locktypes: minor copy editor fixes
Quoted 8 lines · Randy Dunlap
From: Randy Dunlap <[email protected]>
Minor editorial fixes:
- add some hyphens in multi-word adjectives
- add some periods for consistency
- add "'" for possessive CPU's
- capitalize IRQ when it's an acronym and not part of a function name
Quoted 7 lines
Signed-off-by Randy Dunlap <[email protected]>Cc Paul McKenney <[email protected]>Cc Thomas Gleixner <[email protected]>Cc Sebastian Siewior <[email protected]>Cc Joel Fernandes <[email protected]>Cc Ingo Molnar <[email protected]>Cc Peter Zijlstra <[email protected]>
Some nits below, but with or without those suggested changes:
Documentation/locking/locktypes.rst rtmutex · line 87
Quoted 12 lines
--- Documentation/locking/locktypes.rst | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)Documentation/locking/locktypes.rst +1
-1@@ -84,7 +84,7 @@ rtmutex RT-mutexes are mutexes with support for priority inheritance (PI). -PI has limitations on non PREEMPT_RT enabled kernels due to preemption and +PI has limitations on non-PREEMPT_RT-enabled kernels due to preemption and
Or just drop the " enabled".
Quoted 13 lines
Documentation/locking/locktypes.rst +1
-1interrupt disabled sections. PI clearly cannot preempt preemption-disabled or interrupt-disabled@@ -150,7 +150,7 @@ kernel configuration including PREEMPT_R raw_spinlock_t is a strict spinning lock implementation in all kernels, including PREEMPT_RT kernels. Use raw_spinlock_t only in real critical -core code, low level interrupt handling and places where disabling +core code, low-level interrupt handling and places where disabling preemption or interrupts is required, for example, to safely access hardware state. raw_spinlock_t can sometimes also be used when the critical section is tiny, thus avoiding RT-mutex overhead.
Documentation/locking/locktypes.rst spinlock_t · line 163
Quoted 5 lines
Documentation/locking/locktypes.rst +1
-1@@ -160,20 +160,20 @@ spinlock_t The semantics of spinlock_t change with the state of PREEMPT_RT. -On a non PREEMPT_RT enabled kernel spinlock_t is mapped to raw_spinlock_t +On a non-PREEMPT_RT-enabled kernel spinlock_t is mapped to raw_spinlock_t
Ditto.
Documentation/locking/locktypes.rst spinlock_t · line 169
Quoted 7 lines
Documentation/locking/locktypes.rst +1
-1and has exactly the same semantics. spinlock_t and PREEMPT_RT ------------------------- -On a PREEMPT_RT enabled kernel spinlock_t is mapped to a separate +On a PREEMPT_RT-enabled kernel spinlock_t is mapped to a separate
And here as well.
Quoted 14 lines
Documentation/locking/locktypes.rst +3
-3implementation based on rt_mutex which changes the semantics: - - Preemption is not disabled + - Preemption is not disabled. - The hard interrupt related suffixes for spin_lock / spin_unlock - operations (_irq, _irqsave / _irqrestore) do not affect the CPUs - interrupt disabled state + operations (_irq, _irqsave / _irqrestore) do not affect the CPU's + interrupt disabled state. - The soft interrupt related suffix (_bh()) still disables softirq handlers.
Documentation/locking/locktypes.rst fully preemptible context. Instead, use · line 282
Quoted 5 lines
Documentation/locking/locktypes.rst +1
-1@@ -279,7 +279,7 @@ fully preemptible context. Instead, use spin_lock_irqsave() and their unlock counterparts. In cases where the interrupt disabling and locking must remain separate, PREEMPT_RT offers a local_lock mechanism. Acquiring the local_lock pins the task to a CPU, -allowing things like per-CPU irq-disabled locks to be acquired. However, +allowing things like per-CPU IRQ-disabled locks to be acquired. However,
Quite a bit of text in the kernel uses "irq", lower case. Another option is to spell out "interrupt".
Quoted 4 lines
Documentation/locking/locktypes.rst +0
-0this approach should be used only where absolutely necessary.
[tip: locking/core] Documentation/locking/locktypes: Minor copy editor fixes
In reply to Randy DunlapThe following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 51e69e6551a8c6fffe0185ba305bb4e2d7223616 Gitweb: https://git.kernel.org/tip/51e69e6551a8c6fffe0185ba305bb4e2d7223616 Author: Randy Dunlap <[email protected]> AuthorDate: Wed, 25 Mar 2020 09:58:14 -07:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Sat, 28 Mar 2020 12:47:34 +01:00
Documentation/locking/locktypes: Minor copy editor fixes
Minor editorial fixes:
- remove 'enabled' from PREEMPT_RT enabled kernels for consistency
- add some periods for consistency
- add "'" for possessive CPU's
- spell out interrupts
[ tglx: Picked up Paul's suggestions ]
--- Documentation/locking/locktypes.rst | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-)
Documentation/locking/locktypes.rst +11 -11
@@ -84,7 +84,7 @@ rtmutex RT-mutexes are mutexes with support for priority inheritance (PI). -PI has limitations on non PREEMPT_RT enabled kernels due to preemption and +PI has limitations on non-PREEMPT_RT kernels due to preemption and interrupt disabled sections. PI clearly cannot preempt preemption-disabled or interrupt-disabled
@@ -150,7 +150,7 @@ kernel configuration including PREEMPT_RT enabled kernels. raw_spinlock_t is a strict spinning lock implementation in all kernels, including PREEMPT_RT kernels. Use raw_spinlock_t only in real critical -core code, low level interrupt handling and places where disabling +core code, low-level interrupt handling and places where disabling preemption or interrupts is required, for example, to safely access hardware state. raw_spinlock_t can sometimes also be used when the critical section is tiny, thus avoiding RT-mutex overhead.
@@ -160,20 +160,20 @@ spinlock_t The semantics of spinlock_t change with the state of PREEMPT_RT. -On a non PREEMPT_RT enabled kernel spinlock_t is mapped to raw_spinlock_t -and has exactly the same semantics. +On a non-PREEMPT_RT kernel spinlock_t is mapped to raw_spinlock_t and has +exactly the same semantics. spinlock_t and PREEMPT_RT ------------------------- -On a PREEMPT_RT enabled kernel spinlock_t is mapped to a separate -implementation based on rt_mutex which changes the semantics: +On a PREEMPT_RT kernel spinlock_t is mapped to a separate implementation +based on rt_mutex which changes the semantics: - - Preemption is not disabled + - Preemption is not disabled. - The hard interrupt related suffixes for spin_lock / spin_unlock - operations (_irq, _irqsave / _irqrestore) do not affect the CPUs - interrupt disabled state + operations (_irq, _irqsave / _irqrestore) do not affect the CPU's + interrupt disabled state. - The soft interrupt related suffix (_bh()) still disables softirq handlers.
@@ -279,8 +279,8 @@ fully preemptible context. Instead, use spin_lock_irq() or spin_lock_irqsave() and their unlock counterparts. In cases where the interrupt disabling and locking must remain separate, PREEMPT_RT offers a local_lock mechanism. Acquiring the local_lock pins the task to a CPU, -allowing things like per-CPU irq-disabled locks to be acquired. However, -this approach should be used only where absolutely necessary. +allowing things like per-CPU interrupt disabled locks to be acquired. +However, this approach should be used only where absolutely necessary. raw_spinlock_t
[tip: locking/core] Documentation/locking/locktypes: Further clarifications and wordsmithing
In reply to Thomas GleixnerThe following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 7ecc6aa522e1b812a2eacc31066945e920b0fde4 Gitweb: https://git.kernel.org/tip/7ecc6aa522e1b812a2eacc31066945e920b0fde4 Author: Thomas Gleixner <[email protected]> AuthorDate: Wed, 25 Mar 2020 13:27:49 +01:00 Committer: Thomas Gleixner <[email protected]> CommitterDate: Sat, 28 Mar 2020 12:47:34 +01:00
Documentation/locking/locktypes: Further clarifications and wordsmithing
The documentation of rw_semaphores is wrong as it claims that the non-owner reader release is not supported by RT. That's just history biased memory distortion.
Split the 'Owner semantics' section up and add separate sections for semaphore and rw_semaphore to reflect reality.
Aside of that the following updates are done:
- Add pseudo code to document the spinlock state preserving mechanism on PREEMPT_RT
- Wordsmith the bitspinlock and lock nesting sections
--- Documentation/locking/locktypes.rst | 148 +++++++++++++++++---------- 1 file changed, 98 insertions(+), 50 deletions(-)
Documentation/locking/locktypes.rst +98 -50
@@ -67,6 +67,17 @@ can have suffixes which apply further protections: _irqsave/restore() Save and disable / restore interrupt disabled state =================== ==================================================== +Owner semantics +=============== + +The aforementioned lock types except semaphores have strict owner +semantics: + + The context (task) that acquired the lock must release it. + +rw_semaphores have a special interface which allows non-owner release for +readers. + rtmutex =======
@@ -83,6 +94,51 @@ interrupt handlers and soft interrupts. This conversion allows spinlock_t and rwlock_t to be implemented via RT-mutexes. +semaphore +========= + +semaphore is a counting semaphore implementation. + +Semaphores are often used for both serialization and waiting, but new use +cases should instead use separate serialization and wait mechanisms, such +as mutexes and completions. + +semaphores and PREEMPT_RT +---------------------------- + +PREEMPT_RT does not change the semaphore implementation because counting +semaphores have no concept of owners, thus preventing PREEMPT_RT from +providing priority inheritance for semaphores. After all, an unknown +owner cannot be boosted. As a consequence, blocking on semaphores can +result in priority inversion. + + +rw_semaphore +============ + +rw_semaphore is a multiple readers and single writer lock mechanism. + +On non-PREEMPT_RT kernels the implementation is fair, thus preventing +writer starvation. + +rw_semaphore complies by default with the strict owner semantics, but there +exist special-purpose interfaces that allow non-owner release for readers. +These interfaces work independent of the kernel configuration. + +rw_semaphore and PREEMPT_RT +--------------------------- + +PREEMPT_RT kernels map rw_semaphore to a separate rt_mutex-based +implementation, thus changing the fairness: + + Because an rw_semaphore writer cannot grant its priority to multiple + readers, a preempted low-priority reader will continue holding its lock, + thus starving even high-priority writers. In contrast, because readers + can grant their priority to a writer, a preempted low-priority writer will + have its priority boosted until it releases the lock, thus preventing that + writer from starving readers. + + raw_spinlock_t and spinlock_t =============================
@@ -102,7 +158,7 @@ critical section is tiny, thus avoiding RT-mutex overhead. spinlock_t ---------- -The semantics of spinlock_t change with the state of CONFIG_PREEMPT_RT. +The semantics of spinlock_t change with the state of PREEMPT_RT. On a non PREEMPT_RT enabled kernel spinlock_t is mapped to raw_spinlock_t and has exactly the same semantics.
@@ -140,7 +196,16 @@ PREEMPT_RT kernels preserve all other spinlock_t semantics: kernels leave task state untouched. However, PREEMPT_RT must change task state if the task blocks during acquisition. Therefore, it saves the current task state before blocking and the corresponding lock wakeup - restores it. + restores it, as shown below:: + + task->state = TASK_INTERRUPTIBLE + lock() + block() + task->saved_state = task->state + task->state = TASK_UNINTERRUPTIBLE + schedule() + lock wakeup + task->state = task->saved_state Other types of wakeups would normally unconditionally set the task state to RUNNING, but that does not work here because the task must remain
@@ -148,7 +213,22 @@ PREEMPT_RT kernels preserve all other spinlock_t semantics: wakeup attempts to awaken a task blocked waiting for a spinlock, it instead sets the saved state to RUNNING. Then, when the lock acquisition completes, the lock wakeup sets the task state to the saved - state, in this case setting it to RUNNING. + state, in this case setting it to RUNNING:: + + task->state = TASK_INTERRUPTIBLE + lock() + block() + task->saved_state = task->state + task->state = TASK_UNINTERRUPTIBLE + schedule() + non lock wakeup + task->saved_state = TASK_RUNNING + + lock wakeup + task->state = task->saved_state + + This ensures that the real wakeup cannot be lost. + rwlock_t ========
@@ -228,17 +308,16 @@ preemption on PREEMPT_RT kernels:: bit spinlocks ------------- -Bit spinlocks are problematic for PREEMPT_RT as they cannot be easily -substituted by an RT-mutex based implementation for obvious reasons. - -The semantics of bit spinlocks are preserved on PREEMPT_RT kernels and the -caveats vs. raw_spinlock_t apply. +PREEMPT_RT cannot substitute bit spinlocks because a single bit is too +small to accommodate an RT-mutex. Therefore, the semantics of bit +spinlocks are preserved on PREEMPT_RT kernels, so that the raw_spinlock_t +caveats also apply to bit spinlocks. -Some bit spinlocks are substituted by regular spinlock_t for PREEMPT_RT but -this requires conditional (#ifdef'ed) code changes at the usage site while -the spinlock_t substitution is simply done by the compiler and the -conditionals are restricted to header files and core implementation of the -locking primitives and the usage sites do not require any changes. +Some bit spinlocks are replaced with regular spinlock_t for PREEMPT_RT +using conditional (#ifdef'ed) code changes at the usage site. In contrast, +usage-site changes are not needed for the spinlock_t substitution. +Instead, conditionals in header files and the core locking implemementation +enable the compiler to do the substitution transparently. Lock type nesting rules
@@ -254,46 +333,15 @@ The most basic rules are: - Spinning lock types can nest inside sleeping lock types. -These rules apply in general independent of CONFIG_PREEMPT_RT. +These constraints apply both in PREEMPT_RT and otherwise. -As PREEMPT_RT changes the lock category of spinlock_t and rwlock_t from -spinning to sleeping this has obviously restrictions how they can nest with -raw_spinlock_t. - -This results in the following nest ordering: +The fact that PREEMPT_RT changes the lock category of spinlock_t and +rwlock_t from spinning to sleeping means that they cannot be acquired while +holding a raw spinlock. This results in the following nesting ordering: 1) Sleeping locks 2) spinlock_t and rwlock_t 3) raw_spinlock_t and bit spinlocks -Lockdep is aware of these constraints to ensure that they are respected. - - -Owner semantics -=============== - -Most lock types in the Linux kernel have strict owner semantics, i.e. the -context (task) which acquires a lock has to release it. - -There are two exceptions: - - - semaphores - - rwsems - -semaphores have no owner semantics for historical reason, and as such -trylock and release operations can be called from any context. They are -often used for both serialization and waiting purposes. That's generally -discouraged and should be replaced by separate serialization and wait -mechanisms, such as mutexes and completions. - -rwsems have grown interfaces which allow non owner release for special -purposes. This usage is problematic on PREEMPT_RT because PREEMPT_RT -substitutes all locking primitives except semaphores with RT-mutex based -implementations to provide priority inheritance for all lock types except -the truly spinning ones. Priority inheritance on ownerless locks is -obviously impossible. - -For now the rwsem non-owner release excludes code which utilizes it from -being used on PREEMPT_RT enabled kernels. In same cases this can be -mitigated by disabling portions of the code, in other cases the complete -functionality has to be disabled until a workable solution has been found. +Lockdep will complain if these constraints are violated, both in +PREEMPT_RT and otherwise.
PATCH v3 14/20 timekeeping: Split jiffies seqlock
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
seqlock consists of a sequence counter and a spinlock_t which is used to serialize the writers. spinlock_t is substituted by a "sleeping" spinlock on PREEMPT_RT enabled kernels which breaks the usage in the timekeeping code as the writers are executed in hard interrupt and therefore non-preemptible context even on PREEMPT_RT.
The spinlock in seqlock cannot be unconditionally replaced by a raw_spinlock_t as many seqlock users have nesting spinlock sections or other code which is not suitable to run in truly atomic context on RT.
Instead of providing a raw_seqlock API for a single use case, open code the seqlock for the jiffies use case and implement it with a raw_spinlock_t and a sequence counter.
--- kernel/time/jiffies.c | 7 ++++--- kernel/time/tick-common.c | 10 ++++++---- kernel/time/tick-sched.c | 19 ++++++++++++------- kernel/time/timekeeping.c | 6 ++++-- kernel/time/timekeeping.h | 3 ++- 5 files changed, 28 insertions(+), 17 deletions(-)
kernel/time/jiffies.c +4 -3
@@ -58,7 +58,8 @@ static struct clocksource clocksource_ji .max_cycles = 10, }; -__cacheline_aligned_in_smp DEFINE_SEQLOCK (jiffies_lock ); +__cacheline_aligned_in_smp DEFINE_RAW_SPINLOCK (jiffies_lock ); +__cacheline_aligned_in_smp seqcount_t jiffies_seq;#if (BITS_PER_LONG <64 )u64 get_jiffies_64 (void )
@@ -67,9 +68,9 @@ u64 get_jiffies_64(void)u64 ret;do { - seq =read_seqbegin (&jiffies_lock); + seq =read_seqcount_begin (&jiffies_seq); ret = jiffies_64; - }while (read_seqretry (&jiffies_lock, seq)); + }while (read_seqcount_retry (&jiffies_seq, seq));return ret; }EXPORT_SYMBOL (get_jiffies_64);
kernel/time/tick-common.c +6 -4
@@ -84,13 +84,15 @@ int tick_is_oneshot_available(void)static void tick_periodic (int cpu) {if (tick_do_timer_cpu == cpu) { -write_seqlock (&jiffies_lock); +raw_spin_lock (&jiffies_lock); +write_seqcount_begin (&jiffies_seq);/* Keep track of the next tick event */ tick_next_period =ktime_add (tick_next_period, tick_period);do_timer (1 ); -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);update_wall_time (); }
@@ -162,9 +164,9 @@ void tick_setup_periodic(struct clock_evktime_t next;do { - seq =read_seqbegin (&jiffies_lock); + seq =read_seqcount_begin (&jiffies_seq); next = tick_next_period; - }while (read_seqretry (&jiffies_lock, seq)); + }while (read_seqcount_retry (&jiffies_seq, seq));clockevents_switch_state (dev,CLOCK_EVT_STATE_ONESHOT );
kernel/time/tick-sched.c +12 -7
@@ -65,7 +65,8 @@ static void tick_do_update_jiffies64(ktireturn ;/* Reevaluate with jiffies_lock held */ -write_seqlock (&jiffies_lock); +raw_spin_lock (&jiffies_lock); +write_seqcount_begin (&jiffies_seq); delta =ktime_sub (now, last_jiffies_update);if (delta >= tick_period) {
@@ -91,10 +92,12 @@ static void tick_do_update_jiffies64(kti/* Keep the tick_next_period variable up to date */ tick_next_period =ktime_add (last_jiffies_update, tick_period); }else { -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);return ; } -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);update_wall_time (); }
@@ -105,12 +108,14 @@ static ktime_t tick_init_jiffy_update(vo {ktime_t period; -write_seqlock (&jiffies_lock); +raw_spin_lock (&jiffies_lock); +write_seqcount_begin (&jiffies_seq);/* Did we start the jiffies update yet ? */ if (last_jiffies_update ==0 ) last_jiffies_update = tick_next_period; period = last_jiffies_update; -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);return period; }
@@ -676,10 +681,10 @@ static ktime_t tick_nohz_next_event(stru/* Read jiffies and the time when jiffies were updated last */ do { - seq =read_seqbegin (&jiffies_lock); + seq =read_seqcount_begin (&jiffies_seq); basemono = last_jiffies_update; basejiff = jiffies; - }while (read_seqretry (&jiffies_lock, seq)); + }while (read_seqcount_retry (&jiffies_seq, seq)); ts->last_jiffies = basejiff; ts->timer_expires_base = basemono;
kernel/time/timekeeping.c +4 -2
@@ -2397,8 +2397,10 @@ EXPORT_SYMBOL(hardpps);*/ void xtime_update (unsigned long ticks) { -write_seqlock (&jiffies_lock); +raw_spin_lock (&jiffies_lock); +write_seqcount_begin (&jiffies_seq);do_timer (ticks); -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);update_wall_time (); }
kernel/time/timekeeping.h +2 -1
@@ -25,7 +25,8 @@ static inline void sched_clock_resume(voextern void do_timer (unsigned long ticks);extern void update_wall_time (void ); -extern seqlock_t jiffies_lock; +extern raw_spinlock_t jiffies_lock; +extern seqcount_t jiffies_seq;#define CS_NAME_LEN 32
[tip: locking/core] timekeeping: Split jiffies seqlock
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: e5d4d1756b07d9490a0269a9e68c1e05ee1feb9b Gitweb: https://git.kernel.org/tip/e5d4d1756b07d9490a0269a9e68c1e05ee1feb9b Author: Thomas Gleixner <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:58 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:23 +01:00
timekeeping: Split jiffies seqlock
seqlock consists of a sequence counter and a spinlock_t which is used to serialize the writers. spinlock_t is substituted by a "sleeping" spinlock on PREEMPT_RT enabled kernels which breaks the usage in the timekeeping code as the writers are executed in hard interrupt and therefore non-preemptible context even on PREEMPT_RT.
The spinlock in seqlock cannot be unconditionally replaced by a raw_spinlock_t as many seqlock users have nesting spinlock sections or other code which is not suitable to run in truly atomic context on RT.
Instead of providing a raw_seqlock API for a single use case, open code the seqlock for the jiffies use case and implement it with a raw_spinlock_t and a sequence counter.
--- kernel/time/jiffies.c | 7 ++++--- kernel/time/tick-common.c | 10 ++++++---- kernel/time/tick-sched.c | 19 ++++++++++++------- kernel/time/timekeeping.c | 6 ++++-- kernel/time/timekeeping.h | 3 ++- 5 files changed, 28 insertions(+), 17 deletions(-)
kernel/time/jiffies.c +4 -3
@@ -58,7 +58,8 @@ static struct clocksource clocksource_jiffies = { .max_cycles = 10, }; -__cacheline_aligned_in_smp DEFINE_SEQLOCK (jiffies_lock ); +__cacheline_aligned_in_smp DEFINE_RAW_SPINLOCK (jiffies_lock ); +__cacheline_aligned_in_smp seqcount_t jiffies_seq;#if (BITS_PER_LONG <64 )u64 get_jiffies_64 (void )
@@ -67,9 +68,9 @@ u64 get_jiffies_64(void)u64 ret;do { - seq =read_seqbegin (&jiffies_lock); + seq =read_seqcount_begin (&jiffies_seq); ret = jiffies_64; - }while (read_seqretry (&jiffies_lock, seq)); + }while (read_seqcount_retry (&jiffies_seq, seq));return ret; }EXPORT_SYMBOL (get_jiffies_64);
kernel/time/tick-common.c +6 -4
@@ -84,13 +84,15 @@ int tick_is_oneshot_available(void)static void tick_periodic (int cpu) {if (tick_do_timer_cpu == cpu) { -write_seqlock (&jiffies_lock); +raw_spin_lock (&jiffies_lock); +write_seqcount_begin (&jiffies_seq);/* Keep track of the next tick event */ tick_next_period =ktime_add (tick_next_period, tick_period);do_timer (1 ); -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);update_wall_time (); }
@@ -162,9 +164,9 @@ void tick_setup_periodic(struct clock_event_device *dev, int broadcast)ktime_t next;do { - seq =read_seqbegin (&jiffies_lock); + seq =read_seqcount_begin (&jiffies_seq); next = tick_next_period; - }while (read_seqretry (&jiffies_lock, seq)); + }while (read_seqcount_retry (&jiffies_seq, seq));clockevents_switch_state (dev,CLOCK_EVT_STATE_ONESHOT );
kernel/time/tick-sched.c +12 -7
@@ -65,7 +65,8 @@ static void tick_do_update_jiffies64(ktime_t now)return ;/* Reevaluate with jiffies_lock held */ -write_seqlock (&jiffies_lock); +raw_spin_lock (&jiffies_lock); +write_seqcount_begin (&jiffies_seq); delta =ktime_sub (now, last_jiffies_update);if (delta >= tick_period) {
@@ -91,10 +92,12 @@ static void tick_do_update_jiffies64(ktime_t now)/* Keep the tick_next_period variable up to date */ tick_next_period =ktime_add (last_jiffies_update, tick_period); }else { -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);return ; } -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);update_wall_time (); }
@@ -105,12 +108,14 @@ static ktime_t tick_init_jiffy_update(void) {ktime_t period; -write_seqlock (&jiffies_lock); +raw_spin_lock (&jiffies_lock); +write_seqcount_begin (&jiffies_seq);/* Did we start the jiffies update yet ? */ if (last_jiffies_update ==0 ) last_jiffies_update = tick_next_period; period = last_jiffies_update; -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);return period; }
@@ -676,10 +681,10 @@ static ktime_t tick_nohz_next_event(struct tick_sched *ts, int cpu)/* Read jiffies and the time when jiffies were updated last */ do { - seq =read_seqbegin (&jiffies_lock); + seq =read_seqcount_begin (&jiffies_seq); basemono = last_jiffies_update; basejiff = jiffies; - }while (read_seqretry (&jiffies_lock, seq)); + }while (read_seqcount_retry (&jiffies_seq, seq)); ts->last_jiffies = basejiff; ts->timer_expires_base = basemono;
kernel/time/timekeeping.c +4 -2
@@ -2397,8 +2397,10 @@ EXPORT_SYMBOL(hardpps);*/ void xtime_update (unsigned long ticks) { -write_seqlock (&jiffies_lock); +raw_spin_lock (&jiffies_lock); +write_seqcount_begin (&jiffies_seq);do_timer (ticks); -write_sequnlock (&jiffies_lock); +write_seqcount_end (&jiffies_seq); +raw_spin_unlock (&jiffies_lock);update_wall_time (); }
kernel/time/timekeeping.h +2 -1
@@ -25,7 +25,8 @@ static inline void sched_clock_resume(void) { }extern void do_timer (unsigned long ticks);extern void update_wall_time (void ); -extern seqlock_t jiffies_lock; +extern raw_spinlock_t jiffies_lock; +extern seqcount_t jiffies_seq;#define CS_NAME_LEN 32
PATCH v3 15/20 sched/swait: Prepare usage in completions
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
As a preparation to use simple wait queues for completions:
- Provide swake_up_all_locked() to support complete_all()
- Make __prepare_to_swait() public available
This is done to enable the usage of complete() within truly atomic contexts on a PREEMPT_RT enabled kernel.
---
V2: Add comment to swake_up_all_locked()
--- kernel/sched/sched.h | 3 +++ kernel/sched/swait.c | 15 ++++++++++++++- 2 files changed, 17 insertions(+), 1 deletion(-)
kernel/sched/sched.h +3 -0
@@ -2492,3 +2492,6 @@ static inline bool is_per_cpu_kthread(st return true; }#endif + +void swake_up_all_locked (struct swait_queue_head *q); +void __prepare_to_swait (struct swait_queue_head *q,struct swait_queue *wait);
kernel/sched/swait.c +14 -1
@@ -32,6 +32,19 @@ void swake_up_locked(struct swait_queue_ }EXPORT_SYMBOL (swake_up_locked); +/* +* Wake up all waiters. This is an interface which is solely exposed for +* completions and not for general usage. +* +* It is intentionally different from swake_up_all() to allow usage from +* hard interrupt context and interrupt disabled regions. +*/ +void swake_up_all_locked (struct swait_queue_head *q) +{ +while (!list_empty (&q->task_list)) +swake_up_locked (q); +} +void swake_up_one (struct swait_queue_head *q) {unsigned long flags;
@@ -69,7 +82,7 @@ void swake_up_all(struct swait_queue_hea }EXPORT_SYMBOL (swake_up_all); -static void __prepare_to_swait (struct swait_queue_head *q,struct swait_queue *wait) +void __prepare_to_swait (struct swait_queue_head *q,struct swait_queue *wait) { wait->task = current;if (list_empty (&wait->task_list))
[tip: locking/core] sched/swait: Prepare usage in completions
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: b3212fe2bc06fa1014b3063b85b2bac4332a1c28 Gitweb: https://git.kernel.org/tip/b3212fe2bc06fa1014b3063b85b2bac4332a1c28 Author: Thomas Gleixner <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:25:59 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:23 +01:00
sched/swait: Prepare usage in completions
As a preparation to use simple wait queues for completions:
- Provide swake_up_all_locked() to support complete_all()
- Make __prepare_to_swait() public available
This is done to enable the usage of complete() within truly atomic contexts on a PREEMPT_RT enabled kernel.
--- kernel/sched/sched.h | 3 +++ kernel/sched/swait.c | 15 ++++++++++++++- 2 files changed, 17 insertions(+), 1 deletion(-)
kernel/sched/sched.h +3 -0
@@ -2492,3 +2492,6 @@ static inline bool is_per_cpu_kthread(struct task_struct *p) return true; }#endif + +void swake_up_all_locked (struct swait_queue_head *q); +void __prepare_to_swait (struct swait_queue_head *q,struct swait_queue *wait);
kernel/sched/swait.c +14 -1
@@ -32,6 +32,19 @@ void swake_up_locked(struct swait_queue_head *q) }EXPORT_SYMBOL (swake_up_locked); +/* +* Wake up all waiters. This is an interface which is solely exposed for +* completions and not for general usage. +* +* It is intentionally different from swake_up_all() to allow usage from +* hard interrupt context and interrupt disabled regions. +*/ +void swake_up_all_locked (struct swait_queue_head *q) +{ +while (!list_empty (&q->task_list)) +swake_up_locked (q); +} +void swake_up_one (struct swait_queue_head *q) {unsigned long flags;
@@ -69,7 +82,7 @@ void swake_up_all(struct swait_queue_head *q) }EXPORT_SYMBOL (swake_up_all); -static void __prepare_to_swait (struct swait_queue_head *q,struct swait_queue *wait) +void __prepare_to_swait (struct swait_queue_head *q,struct swait_queue *wait) { wait->task = current;if (list_empty (&wait->task_list))
PATCH v3 16/20 completion: Use simple wait queues
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
completion uses a wait_queue_head_t to enqueue waiters.
wait_queue_head_t contains a spinlock_t to protect the list of waiters which excludes it from being used in truly atomic context on a PREEMPT_RT enabled kernel.
The spinlock in the wait queue head cannot be replaced by a raw_spinlock because:
- wait queues can have custom wakeup callbacks, which acquire other spinlock_t locks and have potentially long execution times
- wake_up() walks an unbounded number of list entries during the wake up and may wake an unbounded number of waiters.
For simplicity and performance reasons complete() should be usable on PREEMPT_RT enabled kernels.
completions do not use custom wakeup callbacks and are usually single waiter, except for a few corner cases.
Replace the wait queue in the completion with a simple wait queue (swait), which uses a raw_spinlock_t for protecting the waiter list and therefore is safe to use inside truly atomic regions on PREEMPT_RT.
There is no semantical or functional change:
- completions use the exclusive wait mode which is what swait provides
- complete() wakes one exclusive waiter
- complete_all() wakes all waiters while holding the lock which protects the wait queue against newly incoming waiters. The conversion to swait preserves this behaviour.
complete_all() might cause unbound latencies with a large number of waiters being woken at once, but most complete_all() usage sites are either in testing or initialization code or have only a really small number of concurrent waiters which for now does not cause a latency problem. Keep it simple for now.
The fixup of the warning check in the USB gadget driver is just a straight forward conversion of the lockless waiter check from one waitqueue type to the other.
---
V2: Split out the orinoco and usb gadget parts and amended change log
--- drivers/usb/gadget/function/f_fs.c | 2 +- include/linux/completion.h | 8 ++++---- kernel/sched/completion.c | 36 +++++++++++++++++++----------------- 3 files changed, 24 insertions(+), 22 deletions(-)
drivers/usb/gadget/function/f_fs.c +1 -1
@@ -1703,7 +1703,7 @@ static void ffs_data_put(struct ffs_datapr_info ("%s(): freeing\n" , __func__);ffs_data_clear (ffs);BUG_ON (waitqueue_active (&ffs->ev.waitq) || -waitqueue_active (&ffs->ep0req_completion.wait) || +swait_active (&ffs->ep0req_completion.wait) ||waitqueue_active (&ffs->wait));destroy_workqueue (ffs->io_completion_wq);kfree (ffs->dev_name);
include/linux/completion.h +4 -4
@@ -9,7 +9,7 @@* See kernel/sched/completion.c for details. */ -#include <linux/wait.h> +#include <linux/swait.h> /* * struct completion - structure used to maintain state for a "completion"
@@ -25,7 +25,7 @@*/ struct completion {unsigned int done; -wait_queue_head_t wait; +struct swait_queue_head wait; };#define init_completion_map (x, m) __init_completion(x)
@@ -34,7 +34,7 @@ static inline void complete_acquire(strustatic inline void complete_release (struct completion *x) {}#define COMPLETION_INITIALIZER (work) \ - { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) } + { 0, __SWAIT_QUEUE_HEAD_INITIALIZER((work).wait) }#define COMPLETION_INITIALIZER_ONSTACK_MAP (work, map) \ (*({ init_completion_map(&(work), &(map)); &(work); }))
@@ -85,7 +85,7 @@ static inline void complete_release(strustatic inline void __init_completion (struct completion *x) { x->done =0 ; -init_waitqueue_head (&x->wait); +init_swait_queue_head (&x->wait); }/**
kernel/sched/completion.c +19 -17
@@ -29,12 +29,12 @@ void complete(struct completion *x) {unsigned long flags; -spin_lock_irqsave (&x->wait.lock, flags); +raw_spin_lock_irqsave (&x->wait.lock, flags);if (x->done !=UINT_MAX ) x->done++; -__wake_up_locked (&x->wait,TASK_NORMAL ,1 ); -spin_unlock_irqrestore (&x->wait.lock, flags); +swake_up_locked (&x->wait); +raw_spin_unlock_irqrestore (&x->wait.lock, flags); }EXPORT_SYMBOL (complete);
@@ -58,10 +58,12 @@ void complete_all(struct completion *x) {unsigned long flags; -spin_lock_irqsave (&x->wait.lock, flags); +WARN_ON (irqs_disabled ()); + +raw_spin_lock_irqsave (&x->wait.lock, flags); x->done =UINT_MAX ; -__wake_up_locked (&x->wait,TASK_NORMAL ,0 ); -spin_unlock_irqrestore (&x->wait.lock, flags); +swake_up_all_locked (&x->wait); +raw_spin_unlock_irqrestore (&x->wait.lock, flags); }EXPORT_SYMBOL (complete_all);
@@ -70,20 +72,20 @@ do_wait_for_common(struct completion *x, long (*action)(long), long timeout, int state) { if (!x->done) { -DECLARE_WAITQUEUE (wait ,current ); +DECLARE_SWAITQUEUE (wait ); -__add_wait_queue_entry_tail_exclusive (&x->wait, &wait);do {if (signal_pending_state (state, current)) { timeout = -ERESTARTSYS ;break ; } +__prepare_to_swait (&x->wait, &wait);__set_current_state (state); -spin_unlock_irq (&x->wait.lock); +raw_spin_unlock_irq (&x->wait.lock); timeout =action (timeout); -spin_lock_irq (&x->wait.lock); +raw_spin_lock_irq (&x->wait.lock); }while (!x->done && timeout); -__remove_wait_queue (&x->wait, &wait); +__finish_swait (&x->wait, &wait);if (!x->done)return timeout; }
@@ -100,9 +102,9 @@ static inline long __schedcomplete_acquire (x); -spin_lock_irq (&x->wait.lock); +raw_spin_lock_irq (&x->wait.lock); timeout =do_wait_for_common (x, action, timeout, state); -spin_unlock_irq (&x->wait.lock); +raw_spin_unlock_irq (&x->wait.lock);complete_release (x);
@@ -291,12 +293,12 @@ bool try_wait_for_completion(struct compif (!READ_ONCE (x->done))return false; -spin_lock_irqsave (&x->wait.lock, flags); +raw_spin_lock_irqsave (&x->wait.lock, flags);if (!x->done) ret = false;else if (x->done !=UINT_MAX ) x->done--; -spin_unlock_irqrestore (&x->wait.lock, flags); +raw_spin_unlock_irqrestore (&x->wait.lock, flags);return ret; }EXPORT_SYMBOL (try_wait_for_completion);
@@ -322,8 +324,8 @@ bool completion_done(struct completion ** otherwise we can end up freeing the completion before complete() * is done referencing it. */ -spin_lock_irqsave (&x->wait.lock, flags); -spin_unlock_irqrestore (&x->wait.lock, flags); +raw_spin_lock_irqsave (&x->wait.lock, flags); +raw_spin_unlock_irqrestore (&x->wait.lock, flags);return true; }EXPORT_SYMBOL (completion_done);
[tip: locking/core] completion: Use simple wait queues
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: a5c6234e10280b3ec65e2410ce34904a2580e5f8 Gitweb: https://git.kernel.org/tip/a5c6234e10280b3ec65e2410ce34904a2580e5f8 Author: Thomas Gleixner <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:26:00 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:24 +01:00
completion: Use simple wait queues
completion uses a wait_queue_head_t to enqueue waiters.
wait_queue_head_t contains a spinlock_t to protect the list of waiters which excludes it from being used in truly atomic context on a PREEMPT_RT enabled kernel.
The spinlock in the wait queue head cannot be replaced by a raw_spinlock because:
- wait queues can have custom wakeup callbacks, which acquire other spinlock_t locks and have potentially long execution times
- wake_up() walks an unbounded number of list entries during the wake up and may wake an unbounded number of waiters.
For simplicity and performance reasons complete() should be usable on PREEMPT_RT enabled kernels.
completions do not use custom wakeup callbacks and are usually single waiter, except for a few corner cases.
Replace the wait queue in the completion with a simple wait queue (swait), which uses a raw_spinlock_t for protecting the waiter list and therefore is safe to use inside truly atomic regions on PREEMPT_RT.
There is no semantical or functional change:
- completions use the exclusive wait mode which is what swait provides
- complete() wakes one exclusive waiter
- complete_all() wakes all waiters while holding the lock which protects the wait queue against newly incoming waiters. The conversion to swait preserves this behaviour.
complete_all() might cause unbound latencies with a large number of waiters being woken at once, but most complete_all() usage sites are either in testing or initialization code or have only a really small number of concurrent waiters which for now does not cause a latency problem. Keep it simple for now.
The fixup of the warning check in the USB gadget driver is just a straight forward conversion of the lockless waiter check from one waitqueue type to the other.
--- drivers/usb/gadget/function/f_fs.c | 2 +- include/linux/completion.h | 8 +++--- kernel/sched/completion.c | 36 +++++++++++++++-------------- 3 files changed, 24 insertions(+), 22 deletions(-)
drivers/usb/gadget/function/f_fs.c +1 -1
@@ -1703,7 +1703,7 @@ static void ffs_data_put(struct ffs_data *ffs)pr_info ("%s(): freeing\n" , __func__);ffs_data_clear (ffs);BUG_ON (waitqueue_active (&ffs->ev.waitq) || -waitqueue_active (&ffs->ep0req_completion.wait) || +swait_active (&ffs->ep0req_completion.wait) ||waitqueue_active (&ffs->wait));destroy_workqueue (ffs->io_completion_wq);kfree (ffs->dev_name);
include/linux/completion.h +4 -4
@@ -9,7 +9,7 @@* See kernel/sched/completion.c for details. */ -#include <linux/wait.h> +#include <linux/swait.h> /* * struct completion - structure used to maintain state for a "completion"
@@ -25,7 +25,7 @@*/ struct completion {unsigned int done; -wait_queue_head_t wait; +struct swait_queue_head wait; };#define init_completion_map (x, m) __init_completion(x)
@@ -34,7 +34,7 @@ static inline void complete_acquire(struct completion *x) {}static inline void complete_release (struct completion *x) {}#define COMPLETION_INITIALIZER (work) \ - { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) } + { 0, __SWAIT_QUEUE_HEAD_INITIALIZER((work).wait) }#define COMPLETION_INITIALIZER_ONSTACK_MAP (work, map) \ (*({ init_completion_map(&(work), &(map)); &(work); }))
@@ -85,7 +85,7 @@ static inline void complete_release(struct completion *x) {}static inline void __init_completion (struct completion *x) { x->done =0 ; -init_waitqueue_head (&x->wait); +init_swait_queue_head (&x->wait); }/**
kernel/sched/completion.c +19 -17
@@ -29,12 +29,12 @@ void complete(struct completion *x) {unsigned long flags; -spin_lock_irqsave (&x->wait.lock, flags); +raw_spin_lock_irqsave (&x->wait.lock, flags);if (x->done !=UINT_MAX ) x->done++; -__wake_up_locked (&x->wait,TASK_NORMAL ,1 ); -spin_unlock_irqrestore (&x->wait.lock, flags); +swake_up_locked (&x->wait); +raw_spin_unlock_irqrestore (&x->wait.lock, flags); }EXPORT_SYMBOL (complete);
@@ -58,10 +58,12 @@ void complete_all(struct completion *x) {unsigned long flags; -spin_lock_irqsave (&x->wait.lock, flags); +WARN_ON (irqs_disabled ()); + +raw_spin_lock_irqsave (&x->wait.lock, flags); x->done =UINT_MAX ; -__wake_up_locked (&x->wait,TASK_NORMAL ,0 ); -spin_unlock_irqrestore (&x->wait.lock, flags); +swake_up_all_locked (&x->wait); +raw_spin_unlock_irqrestore (&x->wait.lock, flags); }EXPORT_SYMBOL (complete_all);
@@ -70,20 +72,20 @@ do_wait_for_common(struct completion *x, long (*action)(long), long timeout, int state) { if (!x->done) { -DECLARE_WAITQUEUE (wait ,current ); +DECLARE_SWAITQUEUE (wait ); -__add_wait_queue_entry_tail_exclusive (&x->wait, &wait);do {if (signal_pending_state (state, current)) { timeout = -ERESTARTSYS ;break ; } +__prepare_to_swait (&x->wait, &wait);__set_current_state (state); -spin_unlock_irq (&x->wait.lock); +raw_spin_unlock_irq (&x->wait.lock); timeout =action (timeout); -spin_lock_irq (&x->wait.lock); +raw_spin_lock_irq (&x->wait.lock); }while (!x->done && timeout); -__remove_wait_queue (&x->wait, &wait); +__finish_swait (&x->wait, &wait);if (!x->done)return timeout; }
@@ -100,9 +102,9 @@ __wait_for_common(struct completion *x,complete_acquire (x); -spin_lock_irq (&x->wait.lock); +raw_spin_lock_irq (&x->wait.lock); timeout =do_wait_for_common (x, action, timeout, state); -spin_unlock_irq (&x->wait.lock); +raw_spin_unlock_irq (&x->wait.lock);complete_release (x);
@@ -291,12 +293,12 @@ bool try_wait_for_completion(struct completion *x)if (!READ_ONCE (x->done))return false; -spin_lock_irqsave (&x->wait.lock, flags); +raw_spin_lock_irqsave (&x->wait.lock, flags);if (!x->done) ret = false;else if (x->done !=UINT_MAX ) x->done--; -spin_unlock_irqrestore (&x->wait.lock, flags); +raw_spin_unlock_irqrestore (&x->wait.lock, flags);return ret; }EXPORT_SYMBOL (try_wait_for_completion);
@@ -322,8 +324,8 @@ bool completion_done(struct completion *x)* otherwise we can end up freeing the completion before complete() * is done referencing it. */ -spin_lock_irqsave (&x->wait.lock, flags); -spin_unlock_irqrestore (&x->wait.lock, flags); +raw_spin_lock_irqsave (&x->wait.lock, flags); +raw_spin_unlock_irqrestore (&x->wait.lock, flags);return true; }EXPORT_SYMBOL (completion_done);
PATCH 1/1 completion: Use lockdep_assert_RT_in_threaded_ctx() in complete_all()
In reply to Thomas GleixnerThe warning was intended to spot complete_all() users from hardirq context on PREEMPT_RT. The warning as-is will also trigger in interrupt handlers, which are threaded on PREEMPT_RT, which was not intended.
Use lockdep_assert_RT_in_threaded_ctx() which triggers in non-preemptive context on PREEMPT_RT.
--- include/linux/lockdep.h | 15 +++++++++++++++ kernel/sched/completion.c | 2 +- 2 files changed, 16 insertions(+), 1 deletion(-)
include/linux/lockdep.h +15 -0
@@ -711,6 +711,21 @@ do { \# define lockdep_assert_in_irq () do { } while (0)#endif +#ifdef CONFIG_PROVE_RAW_LOCK_NESTING + +# define lockdep_assert_RT_in_threaded_ctx () do { \ + WARN_ONCE(debug_locks && !current->lockdep_recursion && \ + current->hardirq_context && \ + !(current->hardirq_threaded || current->irq_config), \ + "Not in threaded context on PREEMPT_RT as expected\n"); \ +} while (0) + +#else + +# define lockdep_assert_RT_in_threaded_ctx () do { } while (0) + +#endif +#ifdef CONFIG_LOCKDEP void lockdep_rcu_suspicious (const char *file,const int line,const char *s);#else
kernel/sched/completion.c +1 -1
@@ -58,7 +58,7 @@ void complete_all(struct completion *x) {unsigned long flags; -WARN_ON (irqs_disabled ()); +lockdep_assert_RT_in_threaded_ctx ();raw_spin_lock_irqsave (&x->wait.lock, flags); x->done =UINT_MAX ;
Signature · 1 line
2.26.0.rc2
[tip: locking/core] completion: Use lockdep_assert_RT_in_threaded_ctx() in complete_all()
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 8bf6c677ddb9c922423ea3bf494fe7c508bfbb8c Gitweb: https://git.kernel.org/tip/8bf6c677ddb9c922423ea3bf494fe7c508bfbb8c Author: Sebastian Siewior <[email protected]> AuthorDate: Mon, 23 Mar 2020 16:20:19 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Mon, 23 Mar 2020 18:40:25 +01:00
completion: Use lockdep_assert_RT_in_threaded_ctx() in complete_all()
The warning was intended to spot complete_all() users from hardirq context on PREEMPT_RT. The warning as-is will also trigger in interrupt handlers, which are threaded on PREEMPT_RT, which was not intended.
Use lockdep_assert_RT_in_threaded_ctx() which triggers in non-preemptive context on PREEMPT_RT.
--- include/linux/lockdep.h | 15 +++++++++++++++ kernel/sched/completion.c | 2 +- 2 files changed, 16 insertions(+), 1 deletion(-)
include/linux/lockdep.h +15 -0
@@ -711,6 +711,21 @@ do { \# define lockdep_assert_in_irq () do { } while (0)#endif +#ifdef CONFIG_PROVE_RAW_LOCK_NESTING + +# define lockdep_assert_RT_in_threaded_ctx () do { \ + WARN_ONCE(debug_locks && !current->lockdep_recursion && \ + current->hardirq_context && \ + !(current->hardirq_threaded || current->irq_config), \ + "Not in threaded context on PREEMPT_RT as expected\n"); \ +} while (0) + +#else + +# define lockdep_assert_RT_in_threaded_ctx () do { } while (0) + +#endif +#ifdef CONFIG_LOCKDEP void lockdep_rcu_suspicious (const char *file,const int line,const char *s);#else
kernel/sched/completion.c +1 -1
@@ -58,7 +58,7 @@ void complete_all(struct completion *x) {unsigned long flags; -WARN_ON (irqs_disabled ()); +lockdep_assert_RT_in_threaded_ctx ();raw_spin_lock_irqsave (&x->wait.lock, flags); x->done =UINT_MAX ;
PATCH v3 17/20 lockdep: Introduce wait-type checks
In reply to Thomas GleixnerFrom: Peter Zijlstra <[email protected]>
Extend lockdep to validate lock wait-type context.
The current wait-types are:
LD_WAIT_FREE, /* wait free, rcu etc.. */ LD_WAIT_SPIN, /* spin loops, raw_spinlock_t etc.. */ LD_WAIT_CONFIG, /* CONFIG_PREEMPT_LOCK, spinlock_t etc.. */ LD_WAIT_SLEEP, /* sleeping locks, mutex_t etc.. */
Where lockdep validates that the current lock (the one being acquired) fits in the current wait-context (as generated by the held stack).
This ensures that there is no attempt to acquire mutexes while holding spinlocks, to acquire spinlocks while holding raw_spinlocks and so on. In other words, its a more fancy might_sleep().
Obviously RCU made the entire ordeal more complex than a simple single value test because RCU can be acquired in (pretty much) any context and while it presents a context to nested locks it is not the same as it got acquired in.
Therefore its necessary to split the wait_type into two values, one representing the acquire (outer) and one representing the nested context (inner). For most 'normal' locks these two are the same.
[ To make static initialization easier we have the rule that:
.outer == INV means .outer == .inner; because INV == 0. ]
It further means that its required to find the minimal .inner of the held stack to compare against the outer of the new lock; because while 'normal' RCU presents a CONFIG type to nested locks, if it is taken while already holding a SPIN type it obviously doesn't relax the rules.
Below is an example output generated by the trivial test code:
raw_spin_lock(&foo); spin_lock(&bar); spin_unlock(&bar); raw_spin_unlock(&foo);
[ BUG: Invalid wait context ]
-----------------------------
swapper/0/1 is trying to lock:
ffffc90000013f20 (&bar){....}-{3:3}, at: kernel_init+0xdb/0x187 other info that might help us debug this:
1 lock held by swapper/0/1:
#0: ffffc90000013ee0 (&foo){+.+.}-{2:2}, at: kernel_init+0xd1/0x187
The way to read it is to look at the new -{n,m} part in the lock description; -{3:3} for the attempted lock, and try and match that up to the held locks, which in this case is the one: -{2,2}.
This tells that the acquiring lock requires a more relaxed environment than presented by the lock stack.
Currently only the normal locks and RCU are converted, the rest of the lockdep users defaults to .inner = INV which is ignored. More conversions can be done when desired.
The check for spinlock_t nesting is not enabled by default. It's a separate config option for now as there are known problems which are currently addressed. The config option allows to identify these problems and to verify that the solutions found are indeed solving them.
The config switch will be removed and the checks will permanently enabled once the vast majority of issues has been addressed.
[ bigeasy: Move LD_WAIT_FREE,… out of CONFIG_LOCKDEP to avoid compile
failure with CONFIG_DEBUG_SPINLOCK + !CONFIG_LOCKDEP]
[ tglx: Add the config option ]
---
V2: Fix the LOCKDEP=y && LOCK_PROVE=n case
--- include/linux/irqflags.h | 8 ++ include/linux/lockdep.h | 71 +++++++++++++++++--- include/linux/mutex.h | 7 +- include/linux/rwlock_types.h | 6 + include/linux/rwsem.h | 6 + include/linux/sched.h | 1 include/linux/spinlock.h | 35 +++++++--- include/linux/spinlock_types.h | 24 +++++- kernel/irq/handle.c | 7 ++ kernel/locking/lockdep.c | 138 ++++++++++++++++++++++++++++++++++++++-- kernel/locking/mutex-debug.c | 2 kernel/locking/rwsem.c | 2 kernel/locking/spinlock_debug.c | 6 - kernel/rcu/update.c | 24 +++++- lib/Kconfig.debug | 17 ++++ 15 files changed, 307 insertions(+), 47 deletions(-)
include/linux/irqflags.h +7 -1
@@ -37,7 +37,12 @@# define trace_softirqs_enabled (p) ((p)->softirqs_enabled)# define trace_hardirq_enter () \ do { \ - current->hardirq_context++; \ + if (!current->hardirq_context++) \ + current->hardirq_threaded = 0; \ +} while (0) +# define trace_hardirq_threaded () \ +do { \ + current->hardirq_threaded = 1; \ } while (0)# define trace_hardirq_exit () \ do { \
@@ -59,6 +64,7 @@ do { \# define trace_hardirqs_enabled (p) 0# define trace_softirqs_enabled (p) 0# define trace_hardirq_enter () do { } while (0) +# define trace_hardirq_threaded () do { } while (0)# define trace_hardirq_exit () do { } while (0)# define lockdep_softirq_enter () do { } while (0)# define lockdep_softirq_exit () do { } while (0)
include/linux/lockdep.h +60 -11
110 lines not on this page · raw message
include/linux/mutex.h +5 -2
@@ -109,8 +109,11 @@ do { \ } while (0)#ifdef CONFIG_DEBUG_LOCK_ALLOC -# define __DEP_MAP_MUTEX_INITIALIZER (lockname) \ - , .dep_map = { .name = #lockname } +# define __DEP_MAP_MUTEX_INITIALIZER (lockname) \ + , .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_SLEEP, \ + }#else # define __DEP_MAP_MUTEX_INITIALIZER (lockname)#endif
include/linux/rwlock_types.h +5 -1
@@ -22,7 +22,11 @@ typedef struct {#define RWLOCK_MAGIC 0xdeaf1eed#ifdef CONFIG_DEBUG_LOCK_ALLOC -# define RW_DEP_MAP_INIT (lockname) .dep_map = { .name = #lockname } +# define RW_DEP_MAP_INIT (lockname) \ + .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_CONFIG, \ + }#else # define RW_DEP_MAP_INIT (lockname)#endif
include/linux/rwsem.h +5 -1
@@ -71,7 +71,11 @@ static inline int rwsem_is_locked(struct/* Common initializer macros and functions */ #ifdef CONFIG_DEBUG_LOCK_ALLOC -# define __RWSEM_DEP_MAP_INIT (lockname) , .dep_map = { .name = #lockname } +# define __RWSEM_DEP_MAP_INIT (lockname) \ + , .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_SLEEP, \ + }#else # define __RWSEM_DEP_MAP_INIT (lockname)#endif
include/linux/sched.h +1 -0
@@ -970,6 +970,7 @@ struct task_struct {#ifdef CONFIG_TRACE_IRQFLAGS unsigned int irq_events; +unsigned int hardirq_threaded;unsigned long hardirq_enable_ip;unsigned long hardirq_disable_ip;unsigned int hardirq_enable_event;
include/linux/spinlock.h +25 -10
@@ -93,12 +93,13 @@#ifdef CONFIG_DEBUG_SPINLOCK extern void __raw_spin_lock_init (raw_spinlock_t *lock,const char *name, -struct lock_class_key *key); -# define raw_spin_lock_init (lock) \ -do { \ - static struct lock_class_key __key; \ - \ - __raw_spin_lock_init((lock), #lock, &__key); \ +struct lock_class_key *key,short inner); + +# define raw_spin_lock_init (lock) \ +do { \ + static struct lock_class_key __key; \ + \ + __raw_spin_lock_init((lock), #lock, &__key, LD_WAIT_SPIN); \ } while (0)#else
@@ -327,12 +328,26 @@ static __always_inline raw_spinlock_t *sreturn &lock->rlock; } -#define spin_lock_init (_lock) \ -do { \ - spinlock_check(_lock); \ - raw_spin_lock_init(&(_lock)->rlock); \ +#ifdef CONFIG_DEBUG_SPINLOCK + +# define spin_lock_init (lock) \ +do { \ + static struct lock_class_key __key; \ + \ + __raw_spin_lock_init(spinlock_check(lock), \ + #lock, &__key, LD_WAIT_CONFIG); \ +} while (0) + +#else + +# define spin_lock_init (_lock) \ +do { \ + spinlock_check(_lock); \ + *(_lock) = __SPIN_LOCK_UNLOCKED(_lock); \ } while (0) +#endif + static __always_inline void spin_lock(spinlock_t *lock) {raw_spin_lock (&lock->rlock);
include/linux/spinlock_types.h +20 -4
@@ -33,8 +33,18 @@ typedef struct raw_spinlock {#define SPINLOCK_OWNER_INIT ((void *)-1L)#ifdef CONFIG_DEBUG_LOCK_ALLOC -# define SPIN_DEP_MAP_INIT (lockname) .dep_map = { .name = #lockname } +# define RAW_SPIN_DEP_MAP_INIT (lockname) \ + .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_SPIN, \ + } +# define SPIN_DEP_MAP_INIT (lockname) \ + .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_CONFIG, \ + }#else +# define RAW_SPIN_DEP_MAP_INIT (lockname)# define SPIN_DEP_MAP_INIT (lockname)#endif
@@ -51,7 +61,7 @@ typedef struct raw_spinlock { { \ .raw_lock = __ARCH_SPIN_LOCK_UNLOCKED, \ SPIN_DEBUG_INIT(lockname) \ - SPIN_DEP_MAP_INIT(lockname) } + RAW_SPIN_DEP_MAP_INIT(lockname) }#define __RAW_SPIN_LOCK_UNLOCKED (lockname) \ (raw_spinlock_t) __RAW_SPIN_LOCK_INITIALIZER(lockname)
@@ -72,11 +82,17 @@ typedef struct spinlock { }; } spinlock_t; +#define ___SPIN_LOCK_INITIALIZER (lockname) \ + { \ + .raw_lock = __ARCH_SPIN_LOCK_UNLOCKED, \ + SPIN_DEBUG_INIT(lockname) \ + SPIN_DEP_MAP_INIT(lockname) } +#define __SPIN_LOCK_INITIALIZER (lockname) \ - { { .rlock = __RAW_SPIN_LOCK_INITIALIZER(lockname) } } + { { .rlock = ___SPIN_LOCK_INITIALIZER(lockname) } }#define __SPIN_LOCK_UNLOCKED (lockname) \ - (spinlock_t ) __SPIN_LOCK_INITIALIZER(lockname) + (spinlock_t) __SPIN_LOCK_INITIALIZER(lockname)#define DEFINE_SPINLOCK (x) spinlock_t x = __SPIN_LOCK_UNLOCKED(x)
kernel/irq/handle.c +7 -0
@@ -145,6 +145,13 @@ irqreturn_t __handle_irq_event_percpu(stfor_each_action_of_desc (desc, action) {irqreturn_t res; +/* +* If this IRQ would be threaded under force_irqthreads, mark it so. +*/ +if (irq_settings_can_thread (desc) && + !(action->flags & (IRQF_NO_THREAD |IRQF_PERCPU |IRQF_ONESHOT ))) +trace_hardirq_threaded (); +trace_irq_handler_entry (irq, action); res = action->handler (irq, action->dev_id);trace_irq_handler_exit (irq, action, res);
kernel/locking/lockdep.c +132 -6
197 lines not on this page · raw message
kernel/locking/mutex-debug.c +1 -1
@@ -85,7 +85,7 @@ void debug_mutex_init(struct mutex *lock* Make sure we are not reinitializing a held lock: */ debug_check_no_locks_freed ((void *)lock,sizeof (*lock)); -lockdep_init_map (&lock->dep_map, name, key,0 ); +lockdep_init_map_wait (&lock->dep_map, name, key,0 ,LD_WAIT_SLEEP );#endif lock->magic = lock; }
kernel/locking/rwsem.c +1 -1
@@ -329,7 +329,7 @@ void __init_rwsem(struct rw_semaphore *s* Make sure we are not reinitializing a held semaphore: */ debug_check_no_locks_freed ((void *)sem,sizeof (*sem)); -lockdep_init_map (&sem->dep_map, name, key,0 ); +lockdep_init_map_wait (&sem->dep_map, name, key,0 ,LD_WAIT_SLEEP );#endif #ifdef CONFIG_DEBUG_RWSEMS sem->magic = sem;
kernel/locking/spinlock_debug.c +3 -3
@@ -14,14 +14,14 @@#include <linux/export.h> void __raw_spin_lock_init (raw_spinlock_t *lock,const char *name, -struct lock_class_key *key) +struct lock_class_key *key,short inner) {#ifdef CONFIG_DEBUG_LOCK_ALLOC /* * Make sure we are not reinitializing a held lock: */ debug_check_no_locks_freed ((void *)lock,sizeof (*lock)); -lockdep_init_map (&lock->dep_map, name, key,0 ); +lockdep_init_map_wait (&lock->dep_map, name, key,0 , inner);#endif lock->raw_lock = (arch_spinlock_t )__ARCH_SPIN_LOCK_UNLOCKED; lock->magic =SPINLOCK_MAGIC ;
@@ -39,7 +39,7 @@ void __rwlock_init(rwlock_t *lock, const* Make sure we are not reinitializing a held lock: */ debug_check_no_locks_freed ((void *)lock,sizeof (*lock)); -lockdep_init_map (&lock->dep_map, name, key,0 ); +lockdep_init_map_wait (&lock->dep_map, name, key,0 ,LD_WAIT_CONFIG );#endif lock->raw_lock = (arch_rwlock_t ) __ARCH_RW_LOCK_UNLOCKED; lock->magic =RWLOCK_MAGIC ;
kernel/rcu/update.c +18 -6
@@ -227,18 +227,30 @@ core_initcall(rcu_set_runtime_mode);#ifdef CONFIG_DEBUG_LOCK_ALLOC static struct lock_class_key rcu_lock_key; -struct lockdep_map rcu_lock_map = -STATIC_LOCKDEP_MAP_INIT ("rcu_read_lock" , &rcu_lock_key); +struct lockdep_map rcu_lock_map = { + .name ="rcu_read_lock" , + .key = &rcu_lock_key, + .wait_type_outer =LD_WAIT_FREE , + .wait_type_inner =LD_WAIT_CONFIG ,/* XXX PREEMPT_RCU ? */ +};EXPORT_SYMBOL_GPL (rcu_lock_map);static struct lock_class_key rcu_bh_lock_key; -struct lockdep_map rcu_bh_lock_map = -STATIC_LOCKDEP_MAP_INIT ("rcu_read_lock_bh" , &rcu_bh_lock_key); +struct lockdep_map rcu_bh_lock_map = { + .name ="rcu_read_lock_bh" , + .key = &rcu_bh_lock_key, + .wait_type_outer =LD_WAIT_FREE , + .wait_type_inner =LD_WAIT_CONFIG ,/* PREEMPT_LOCK also makes BH preemptible */ +};EXPORT_SYMBOL_GPL (rcu_bh_lock_map);static struct lock_class_key rcu_sched_lock_key; -struct lockdep_map rcu_sched_lock_map = -STATIC_LOCKDEP_MAP_INIT ("rcu_read_lock_sched" , &rcu_sched_lock_key); +struct lockdep_map rcu_sched_lock_map = { + .name ="rcu_read_lock_sched" , + .key = &rcu_sched_lock_key, + .wait_type_outer =LD_WAIT_FREE , + .wait_type_inner =LD_WAIT_SPIN , +};EXPORT_SYMBOL_GPL (rcu_sched_lock_map);static struct lock_class_key rcu_callback_key;
lib/Kconfig.debug +17 -0
@@ -1086,6 +1086,23 @@ config PROVE_LOCKING For more details, see Documentation/locking/lockdep-design.rst. +config PROVE_RAW_LOCK_NESTING + bool "Enable raw_spinlock - spinlock nesting checks" + depends on PROVE_LOCKING + default n + help + Enable the raw_spinlock vs. spinlock nesting checks which ensure + that the lock nesting rules for PREEMPT_RT enabled kernels are + not violated. + + NOTE: There are known nesting problems. So if you enable this + option expect lockdep splats until these problems have been fully + addressed which is work in progress. This config switch allows to + identify and analyze these problems. It will be removed and the + check permanentely enabled once the main issues have been fixed. + + If unsure, select N. + config LOCK_STAT bool "Lock usage statistics" depends on DEBUG_KERNEL && LOCK_DEBUGGING_SUPPORT
[tip: locking/core] lockdep: Introduce wait-type checks
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: de8f5e4f2dc1f032b46afda0a78cab5456974f89 Gitweb: https://git.kernel.org/tip/de8f5e4f2dc1f032b46afda0a78cab5456974f89 Author: Peter Zijlstra <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:26:01 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:24 +01:00
lockdep: Introduce wait-type checks
Extend lockdep to validate lock wait-type context.
The current wait-types are:
LD_WAIT_FREE, /* wait free, rcu etc.. */ LD_WAIT_SPIN, /* spin loops, raw_spinlock_t etc.. */ LD_WAIT_CONFIG, /* CONFIG_PREEMPT_LOCK, spinlock_t etc.. */ LD_WAIT_SLEEP, /* sleeping locks, mutex_t etc.. */
Where lockdep validates that the current lock (the one being acquired) fits in the current wait-context (as generated by the held stack).
This ensures that there is no attempt to acquire mutexes while holding spinlocks, to acquire spinlocks while holding raw_spinlocks and so on. In other words, its a more fancy might_sleep().
Obviously RCU made the entire ordeal more complex than a simple single value test because RCU can be acquired in (pretty much) any context and while it presents a context to nested locks it is not the same as it got acquired in.
Therefore its necessary to split the wait_type into two values, one representing the acquire (outer) and one representing the nested context (inner). For most 'normal' locks these two are the same.
[ To make static initialization easier we have the rule that:
.outer == INV means .outer == .inner; because INV == 0. ]
It further means that its required to find the minimal .inner of the held stack to compare against the outer of the new lock; because while 'normal' RCU presents a CONFIG type to nested locks, if it is taken while already holding a SPIN type it obviously doesn't relax the rules.
Below is an example output generated by the trivial test code:
raw_spin_lock(&foo); spin_lock(&bar); spin_unlock(&bar); raw_spin_unlock(&foo);
[ BUG: Invalid wait context ]
-----------------------------
swapper/0/1 is trying to lock:
ffffc90000013f20 (&bar){....}-{3:3}, at: kernel_init+0xdb/0x187 other info that might help us debug this:
1 lock held by swapper/0/1:
#0: ffffc90000013ee0 (&foo){+.+.}-{2:2}, at: kernel_init+0xd1/0x187
The way to read it is to look at the new -{n,m} part in the lock description; -{3:3} for the attempted lock, and try and match that up to the held locks, which in this case is the one: -{2,2}.
This tells that the acquiring lock requires a more relaxed environment than presented by the lock stack.
Currently only the normal locks and RCU are converted, the rest of the lockdep users defaults to .inner = INV which is ignored. More conversions can be done when desired.
The check for spinlock_t nesting is not enabled by default. It's a separate config option for now as there are known problems which are currently addressed. The config option allows to identify these problems and to verify that the solutions found are indeed solving them.
The config switch will be removed and the checks will permanently enabled once the vast majority of issues has been addressed.
[ bigeasy: Move LD_WAIT_FREE,… out of CONFIG_LOCKDEP to avoid compile
failure with CONFIG_DEBUG_SPINLOCK + !CONFIG_LOCKDEP]
[ tglx: Add the config option ]
--- include/linux/irqflags.h | 8 +- include/linux/lockdep.h | 71 +++++++++++++--- include/linux/mutex.h | 7 +- include/linux/rwlock_types.h | 6 +- include/linux/rwsem.h | 6 +- include/linux/sched.h | 1 +- include/linux/spinlock.h | 35 +++++--- include/linux/spinlock_types.h | 24 ++++- kernel/irq/handle.c | 7 ++- kernel/locking/lockdep.c | 138 +++++++++++++++++++++++++++++-- kernel/locking/mutex-debug.c | 2 +- kernel/locking/rwsem.c | 2 +- kernel/locking/spinlock_debug.c | 6 +- kernel/rcu/update.c | 24 +++-- lib/Kconfig.debug | 17 ++++- 15 files changed, 307 insertions(+), 47 deletions(-)
include/linux/irqflags.h +7 -1
@@ -37,7 +37,12 @@# define trace_softirqs_enabled (p) ((p)->softirqs_enabled)# define trace_hardirq_enter () \ do { \ - current->hardirq_context++; \ + if (!current->hardirq_context++) \ + current->hardirq_threaded = 0; \ +} while (0) +# define trace_hardirq_threaded () \ +do { \ + current->hardirq_threaded = 1; \ } while (0)# define trace_hardirq_exit () \ do { \
@@ -59,6 +64,7 @@ do { \# define trace_hardirqs_enabled (p) 0# define trace_softirqs_enabled (p) 0# define trace_hardirq_enter () do { } while (0) +# define trace_hardirq_threaded () do { } while (0)# define trace_hardirq_exit () do { } while (0)# define lockdep_softirq_enter () do { } while (0)# define lockdep_softirq_exit () do { } while (0)
include/linux/lockdep.h +60 -11
110 lines not on this page · raw message
include/linux/mutex.h +5 -2
@@ -109,8 +109,11 @@ do { \ } while (0)#ifdef CONFIG_DEBUG_LOCK_ALLOC -# define __DEP_MAP_MUTEX_INITIALIZER (lockname) \ - , .dep_map = { .name = #lockname } +# define __DEP_MAP_MUTEX_INITIALIZER (lockname) \ + , .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_SLEEP, \ + }#else # define __DEP_MAP_MUTEX_INITIALIZER (lockname)#endif
include/linux/rwlock_types.h +5 -1
@@ -22,7 +22,11 @@ typedef struct {#define RWLOCK_MAGIC 0xdeaf1eed#ifdef CONFIG_DEBUG_LOCK_ALLOC -# define RW_DEP_MAP_INIT (lockname) .dep_map = { .name = #lockname } +# define RW_DEP_MAP_INIT (lockname) \ + .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_CONFIG, \ + }#else # define RW_DEP_MAP_INIT (lockname)#endif
include/linux/rwsem.h +5 -1
@@ -65,7 +65,11 @@ static inline int rwsem_is_locked(struct rw_semaphore *sem)/* Common initializer macros and functions */ #ifdef CONFIG_DEBUG_LOCK_ALLOC -# define __RWSEM_DEP_MAP_INIT (lockname) , .dep_map = { .name = #lockname } +# define __RWSEM_DEP_MAP_INIT (lockname) \ + , .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_SLEEP, \ + }#else # define __RWSEM_DEP_MAP_INIT (lockname)#endif
include/linux/sched.h +1 -0
@@ -970,6 +970,7 @@ struct task_struct {#ifdef CONFIG_TRACE_IRQFLAGS unsigned int irq_events; +unsigned int hardirq_threaded;unsigned long hardirq_enable_ip;unsigned long hardirq_disable_ip;unsigned int hardirq_enable_event;
include/linux/spinlock.h +25 -10
@@ -93,12 +93,13 @@#ifdef CONFIG_DEBUG_SPINLOCK extern void __raw_spin_lock_init (raw_spinlock_t *lock,const char *name, -struct lock_class_key *key); -# define raw_spin_lock_init (lock) \ -do { \ - static struct lock_class_key __key; \ - \ - __raw_spin_lock_init((lock), #lock, &__key); \ +struct lock_class_key *key,short inner); + +# define raw_spin_lock_init (lock) \ +do { \ + static struct lock_class_key __key; \ + \ + __raw_spin_lock_init((lock), #lock, &__key, LD_WAIT_SPIN); \ } while (0)#else
@@ -327,12 +328,26 @@ static __always_inline raw_spinlock_t *spinlock_check(spinlock_t *lock)return &lock->rlock; } -#define spin_lock_init (_lock) \ -do { \ - spinlock_check(_lock); \ - raw_spin_lock_init(&(_lock)->rlock); \ +#ifdef CONFIG_DEBUG_SPINLOCK + +# define spin_lock_init (lock) \ +do { \ + static struct lock_class_key __key; \ + \ + __raw_spin_lock_init(spinlock_check(lock), \ + #lock, &__key, LD_WAIT_CONFIG); \ +} while (0) + +#else + +# define spin_lock_init (_lock) \ +do { \ + spinlock_check(_lock); \ + *(_lock) = __SPIN_LOCK_UNLOCKED(_lock); \ } while (0) +#endif + static __always_inline void spin_lock(spinlock_t *lock) {raw_spin_lock (&lock->rlock);
include/linux/spinlock_types.h +20 -4
@@ -33,8 +33,18 @@ typedef struct raw_spinlock {#define SPINLOCK_OWNER_INIT ((void *)-1L)#ifdef CONFIG_DEBUG_LOCK_ALLOC -# define SPIN_DEP_MAP_INIT (lockname) .dep_map = { .name = #lockname } +# define RAW_SPIN_DEP_MAP_INIT (lockname) \ + .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_SPIN, \ + } +# define SPIN_DEP_MAP_INIT (lockname) \ + .dep_map = { \ + .name = #lockname, \ + .wait_type_inner = LD_WAIT_CONFIG, \ + }#else +# define RAW_SPIN_DEP_MAP_INIT (lockname)# define SPIN_DEP_MAP_INIT (lockname)#endif
@@ -51,7 +61,7 @@ typedef struct raw_spinlock { { \ .raw_lock = __ARCH_SPIN_LOCK_UNLOCKED, \ SPIN_DEBUG_INIT(lockname) \ - SPIN_DEP_MAP_INIT(lockname) } + RAW_SPIN_DEP_MAP_INIT(lockname) }#define __RAW_SPIN_LOCK_UNLOCKED (lockname) \ (raw_spinlock_t) __RAW_SPIN_LOCK_INITIALIZER(lockname)
@@ -72,11 +82,17 @@ typedef struct spinlock { }; } spinlock_t; +#define ___SPIN_LOCK_INITIALIZER (lockname) \ + { \ + .raw_lock = __ARCH_SPIN_LOCK_UNLOCKED, \ + SPIN_DEBUG_INIT(lockname) \ + SPIN_DEP_MAP_INIT(lockname) } +#define __SPIN_LOCK_INITIALIZER (lockname) \ - { { .rlock = __RAW_SPIN_LOCK_INITIALIZER(lockname) } } + { { .rlock = ___SPIN_LOCK_INITIALIZER(lockname) } }#define __SPIN_LOCK_UNLOCKED (lockname) \ - (spinlock_t ) __SPIN_LOCK_INITIALIZER(lockname) + (spinlock_t) __SPIN_LOCK_INITIALIZER(lockname)#define DEFINE_SPINLOCK (x) spinlock_t x = __SPIN_LOCK_UNLOCKED(x)
kernel/irq/handle.c +7 -0
@@ -145,6 +145,13 @@ irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flagsfor_each_action_of_desc (desc, action) {irqreturn_t res; +/* +* If this IRQ would be threaded under force_irqthreads, mark it so. +*/ +if (irq_settings_can_thread (desc) && + !(action->flags & (IRQF_NO_THREAD |IRQF_PERCPU |IRQF_ONESHOT ))) +trace_hardirq_threaded (); +trace_irq_handler_entry (irq, action); res = action->handler (irq, action->dev_id);trace_irq_handler_exit (irq, action, res);
kernel/locking/lockdep.c +132 -6
197 lines not on this page · raw message
kernel/locking/mutex-debug.c +1 -1
@@ -85,7 +85,7 @@ void debug_mutex_init(struct mutex *lock, const char *name,* Make sure we are not reinitializing a held lock: */ debug_check_no_locks_freed ((void *)lock,sizeof (*lock)); -lockdep_init_map (&lock->dep_map, name, key,0 ); +lockdep_init_map_wait (&lock->dep_map, name, key,0 ,LD_WAIT_SLEEP );#endif lock->magic = lock; }
kernel/locking/rwsem.c +1 -1
@@ -328,7 +328,7 @@ void __init_rwsem(struct rw_semaphore *sem, const char *name,* Make sure we are not reinitializing a held semaphore: */ debug_check_no_locks_freed ((void *)sem,sizeof (*sem)); -lockdep_init_map (&sem->dep_map, name, key,0 ); +lockdep_init_map_wait (&sem->dep_map, name, key,0 ,LD_WAIT_SLEEP );#endif #ifdef CONFIG_DEBUG_RWSEMS sem->magic = sem;
kernel/locking/spinlock_debug.c +3 -3
@@ -14,14 +14,14 @@#include <linux/export.h> void __raw_spin_lock_init (raw_spinlock_t *lock,const char *name, -struct lock_class_key *key) +struct lock_class_key *key,short inner) {#ifdef CONFIG_DEBUG_LOCK_ALLOC /* * Make sure we are not reinitializing a held lock: */ debug_check_no_locks_freed ((void *)lock,sizeof (*lock)); -lockdep_init_map (&lock->dep_map, name, key,0 ); +lockdep_init_map_wait (&lock->dep_map, name, key,0 , inner);#endif lock->raw_lock = (arch_spinlock_t )__ARCH_SPIN_LOCK_UNLOCKED; lock->magic =SPINLOCK_MAGIC ;
@@ -39,7 +39,7 @@ void __rwlock_init(rwlock_t *lock, const char *name,* Make sure we are not reinitializing a held lock: */ debug_check_no_locks_freed ((void *)lock,sizeof (*lock)); -lockdep_init_map (&lock->dep_map, name, key,0 ); +lockdep_init_map_wait (&lock->dep_map, name, key,0 ,LD_WAIT_CONFIG );#endif lock->raw_lock = (arch_rwlock_t ) __ARCH_RW_LOCK_UNLOCKED; lock->magic =RWLOCK_MAGIC ;
kernel/rcu/update.c +18 -6
@@ -227,18 +227,30 @@ core_initcall(rcu_set_runtime_mode);#ifdef CONFIG_DEBUG_LOCK_ALLOC static struct lock_class_key rcu_lock_key; -struct lockdep_map rcu_lock_map = -STATIC_LOCKDEP_MAP_INIT ("rcu_read_lock" , &rcu_lock_key); +struct lockdep_map rcu_lock_map = { + .name ="rcu_read_lock" , + .key = &rcu_lock_key, + .wait_type_outer =LD_WAIT_FREE , + .wait_type_inner =LD_WAIT_CONFIG ,/* XXX PREEMPT_RCU ? */ +};EXPORT_SYMBOL_GPL (rcu_lock_map);static struct lock_class_key rcu_bh_lock_key; -struct lockdep_map rcu_bh_lock_map = -STATIC_LOCKDEP_MAP_INIT ("rcu_read_lock_bh" , &rcu_bh_lock_key); +struct lockdep_map rcu_bh_lock_map = { + .name ="rcu_read_lock_bh" , + .key = &rcu_bh_lock_key, + .wait_type_outer =LD_WAIT_FREE , + .wait_type_inner =LD_WAIT_CONFIG ,/* PREEMPT_LOCK also makes BH preemptible */ +};EXPORT_SYMBOL_GPL (rcu_bh_lock_map);static struct lock_class_key rcu_sched_lock_key; -struct lockdep_map rcu_sched_lock_map = -STATIC_LOCKDEP_MAP_INIT ("rcu_read_lock_sched" , &rcu_sched_lock_key); +struct lockdep_map rcu_sched_lock_map = { + .name ="rcu_read_lock_sched" , + .key = &rcu_sched_lock_key, + .wait_type_outer =LD_WAIT_FREE , + .wait_type_inner =LD_WAIT_SPIN , +};EXPORT_SYMBOL_GPL (rcu_sched_lock_map);static struct lock_class_key rcu_callback_key;
lib/Kconfig.debug +17 -0
@@ -1086,6 +1086,23 @@ config PROVE_LOCKING For more details, see Documentation/locking/lockdep-design.rst. +config PROVE_RAW_LOCK_NESTING + bool "Enable raw_spinlock - spinlock nesting checks" + depends on PROVE_LOCKING + default n + help + Enable the raw_spinlock vs. spinlock nesting checks which ensure + that the lock nesting rules for PREEMPT_RT enabled kernels are + not violated. + + NOTE: There are known nesting problems. So if you enable this + option expect lockdep splats until these problems have been fully + addressed which is work in progress. This config switch allows to + identify and analyze these problems. It will be removed and the + check permanentely enabled once the main issues have been fixed. + + If unsure, select N. + config LOCK_STAT bool "Lock usage statistics" depends on DEBUG_KERNEL && LOCK_DEBUGGING_SUPPORT
PATCH v3 18/20 lockdep: Add hrtimer context tracing bits
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
Set current->irq_config = 1 for hrtimers which are not marked to expire in hard interrupt context during hrtimer_init(). These timers will expire in softirq context on PREEMPT_RT.
Setting this allows lockdep to differentiate these timers. If a timer is marked to expire in hard interrupt context then the timer callback is not supposed to acquire a regular spinlock instead of a raw_spinlock in the expiry callback.
--- include/linux/irqflags.h | 15 +++++++++++++++ include/linux/sched.h | 1 + kernel/locking/lockdep.c | 2 +- kernel/time/hrtimer.c | 6 +++++- 4 files changed, 22 insertions(+), 2 deletions(-)
include/linux/irqflags.h +15 -0
@@ -56,6 +56,19 @@ do { \do { \ current->softirq_context--; \ } while (0) + +# define lockdep_hrtimer_enter (__hrtimer) \ + do { \ + if (!__hrtimer->is_hard) \ + current->irq_config = 1; \ + } while (0) + +# define lockdep_hrtimer_exit (__hrtimer) \ + do { \ + if (!__hrtimer->is_hard) \ + current->irq_config = 0; \ + } while (0) +#else # define trace_hardirqs_on () do { } while (0)# define trace_hardirqs_off () do { } while (0)
@@ -68,6 +81,8 @@ do { \# define trace_hardirq_exit () do { } while (0)# define lockdep_softirq_enter () do { } while (0)# define lockdep_softirq_exit () do { } while (0) +# define lockdep_hrtimer_enter (__hrtimer) do { } while (0) +# define lockdep_hrtimer_exit (__hrtimer) do { } while (0)#endif #if defined(CONFIG_IRQSOFF_TRACER) || \
include/linux/sched.h +1 -0
@@ -983,6 +983,7 @@ struct task_struct {unsigned int softirq_enable_event;int softirqs_enabled;int softirq_context; +int irq_config;#endif #ifdef CONFIG_LOCKDEP
kernel/locking/lockdep.c +1 -1
@@ -3759,7 +3759,7 @@ static int check_wait_context(struct tas/* * Check if force_irqthreads will run us threaded. */ -if (curr->hardirq_threaded) +if (curr->hardirq_threaded || curr->irq_config) curr_inner =LD_WAIT_CONFIG ;else curr_inner =LD_WAIT_SPIN ;
kernel/time/hrtimer.c +5 -1
@@ -1404,7 +1404,7 @@ static void __hrtimer_init(struct hrtime base = softtimer ?HRTIMER_MAX_CLOCK_BASES /2 :0 ; base +=hrtimer_clockid_to_base (clock_id); timer->is_soft = softtimer; - timer->is_hard = !softtimer; + timer->is_hard = !!(mode &HRTIMER_MODE_HARD ); timer->base = &cpu_base->clock_base[base];timerqueue_init (&timer->node); }
@@ -1514,7 +1514,11 @@ static void __run_hrtimer(struct hrtimer*/ raw_spin_unlock_irqrestore (&cpu_base->lock, flags);trace_hrtimer_expire_entry (timer, now); +lockdep_hrtimer_enter (timer); + restart =fn (timer); + +lockdep_hrtimer_exit (timer);trace_hrtimer_expire_exit (timer);raw_spin_lock_irq (&cpu_base->lock);
[tip: locking/core] lockdep: Add hrtimer context tracing bits
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 40db173965c05a1d803451240ed41707d5bd978d Gitweb: https://git.kernel.org/tip/40db173965c05a1d803451240ed41707d5bd978d Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:26:02 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:24 +01:00
lockdep: Add hrtimer context tracing bits
Set current->irq_config = 1 for hrtimers which are not marked to expire in hard interrupt context during hrtimer_init(). These timers will expire in softirq context on PREEMPT_RT.
Setting this allows lockdep to differentiate these timers. If a timer is marked to expire in hard interrupt context then the timer callback is not supposed to acquire a regular spinlock instead of a raw_spinlock in the expiry callback.
--- include/linux/irqflags.h | 15 +++++++++++++++ include/linux/sched.h | 1 + kernel/locking/lockdep.c | 2 +- kernel/time/hrtimer.c | 6 +++++- 4 files changed, 22 insertions(+), 2 deletions(-)
include/linux/irqflags.h +15 -0
@@ -56,6 +56,19 @@ do { \do { \ current->softirq_context--; \ } while (0) + +# define lockdep_hrtimer_enter (__hrtimer) \ + do { \ + if (!__hrtimer->is_hard) \ + current->irq_config = 1; \ + } while (0) + +# define lockdep_hrtimer_exit (__hrtimer) \ + do { \ + if (!__hrtimer->is_hard) \ + current->irq_config = 0; \ + } while (0) +#else # define trace_hardirqs_on () do { } while (0)# define trace_hardirqs_off () do { } while (0)
@@ -68,6 +81,8 @@ do { \# define trace_hardirq_exit () do { } while (0)# define lockdep_softirq_enter () do { } while (0)# define lockdep_softirq_exit () do { } while (0) +# define lockdep_hrtimer_enter (__hrtimer) do { } while (0) +# define lockdep_hrtimer_exit (__hrtimer) do { } while (0)#endif #if defined(CONFIG_IRQSOFF_TRACER) || \
include/linux/sched.h +1 -0
@@ -983,6 +983,7 @@ struct task_struct {unsigned int softirq_enable_event;int softirqs_enabled;int softirq_context; +int irq_config;#endif #ifdef CONFIG_LOCKDEP
kernel/locking/lockdep.c +1 -1
@@ -4025,7 +4025,7 @@ static int check_wait_context(struct task_struct *curr, struct held_lock *next)/* * Check if force_irqthreads will run us threaded. */ -if (curr->hardirq_threaded) +if (curr->hardirq_threaded || curr->irq_config) curr_inner =LD_WAIT_CONFIG ;else curr_inner =LD_WAIT_SPIN ;
kernel/time/hrtimer.c +5 -1
@@ -1404,7 +1404,7 @@ static void __hrtimer_init(struct hrtimer *timer, clockid_t clock_id, base = softtimer ?HRTIMER_MAX_CLOCK_BASES /2 :0 ; base +=hrtimer_clockid_to_base (clock_id); timer->is_soft = softtimer; - timer->is_hard = !softtimer; + timer->is_hard = !!(mode &HRTIMER_MODE_HARD ); timer->base = &cpu_base->clock_base[base];timerqueue_init (&timer->node); }
@@ -1514,7 +1514,11 @@ static void __run_hrtimer(struct hrtimer_cpu_base *cpu_base,*/ raw_spin_unlock_irqrestore (&cpu_base->lock, flags);trace_hrtimer_expire_entry (timer, now); +lockdep_hrtimer_enter (timer); + restart =fn (timer); + +lockdep_hrtimer_exit (timer);trace_hrtimer_expire_exit (timer);raw_spin_lock_irq (&cpu_base->lock);
Frederic Weisbecker
maintainerRe: [tip: locking/core] lockdep: Add hrtimer context tracing bits
Quoted 69 lines · On Sat, Mar 21, 2020 at 03:53:45PM -0000, tip-bot2 for Sebastian Andrzej…
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 40db173965c05a1d803451240ed41707d5bd978d Gitweb: https://git.kernel.org/tip/40db173965c05a1d803451240ed41707d5bd978d Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:26:02 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:24 +01:00lockdep: Add hrtimer context tracing bits
Set
current->irq_config= 1 for hrtimers which are not marked to expire in hard interrupt context duringhrtimer_init(). These timers will expire in softirq context onPREEMPT_RT.Setting this allows lockdep to differentiate these timers. If a timer is marked to expire in hard interrupt context then the timer callback is not supposed to acquire a regular spinlock instead of a
raw_spinlockin the expiry callback.Signed-off-by Sebastian Andrzej Siewior <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>Signed-off-by Peter Zijlstra (Intel) <[email protected]>--- include/linux/irqflags.h | 15 +++++++++++++++ include/linux/sched.h | 1 + kernel/locking/lockdep.c | 2 +- kernel/time/hrtimer.c | 6 +++++- 4 files changed, 22 insertions(+), 2 deletions(-)include/linux/irqflags.h +15
-0@@ -56,6 +56,19 @@ do { \do { \ current->softirq_context--; \ } while (0) + +# define lockdep_hrtimer_enter (__hrtimer) \ + do { \ + if (!__hrtimer->is_hard) \ + current->irq_config = 1; \ + } while (0) + +# define lockdep_hrtimer_exit (__hrtimer) \ + do { \ + if (!__hrtimer->is_hard) \ + current->irq_config = 0; \ + } while (0) +#else # define trace_hardirqs_on () do { } while (0)# define trace_hardirqs_off () do { } while (0)@@ -68,6 +81,8 @@ do { \# define trace_hardirq_exit () do { } while (0)# define lockdep_softirq_enter () do { } while (0)# define lockdep_softirq_exit () do { } while (0) +# define lockdep_hrtimer_enter (__hrtimer) do { } while (0) +# define lockdep_hrtimer_exit (__hrtimer) do { } while (0)#endif #if defined(CONFIG_IRQSOFF_TRACER) || \include/linux/sched.h +0
-0
include/linux/sched.h struct task_struct { · line 986
Quoted 4 lines
include/linux/sched.h +1
-0@@ -983,6 +983,7 @@ struct task_struct {unsigned int softirq_enable_event;int softirqs_enabled;int softirq_context; +int irq_config;
There really need to be some explanation/comment/symbols to clarify what this field is about and the meaning of the values it can take.
Thanks.
PATCH v3 19/20 lockdep: Annotate irq_work
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
Mark irq_work items with IRQ_WORK_HARD_IRQ which should be invoked in hardirq context even on PREEMPT_RT. IRQ_WORK without this flag will be invoked in softirq context on PREEMPT_RT.
Set ->irq_config to 1 for the IRQ_WORK items which are invoked in softirq context so lockdep knows that these can safely acquire a spinlock_t.
--- include/linux/irq_work.h | 2 ++ include/linux/irqflags.h | 13 +++++++++++++ kernel/irq_work.c | 2 ++ kernel/rcu/tree.c | 1 + kernel/time/tick-sched.c | 1 + 5 files changed, 19 insertions(+)
include/linux/irq_work.h +2 -0
@@ -18,6 +18,8 @@/* Doesn't want IPI, wait for tick: */ #define IRQ_WORK_LAZY BIT(2) +/* Run hard IRQ context, even on RT */ +#define IRQ_WORK_HARD_IRQ BIT(3)#define IRQ_WORK_CLAIMED (IRQ_WORK_PENDING | IRQ_WORK_BUSY)
include/linux/irqflags.h +13 -0
@@ -69,6 +69,17 @@ do { \ current->irq_config =0 ; \ } while (0) +# define lockdep_irq_work_enter (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 1; \ + } while (0) +# define lockdep_irq_work_exit (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 0; \ + } while (0) +#else # define trace_hardirqs_on () do { } while (0)# define trace_hardirqs_off () do { } while (0)
@@ -83,6 +94,8 @@ do { \# define lockdep_softirq_exit () do { } while (0)# define lockdep_hrtimer_enter (__hrtimer) do { } while (0)# define lockdep_hrtimer_exit (__hrtimer) do { } while (0) +# define lockdep_irq_work_enter (__work) do { } while (0) +# define lockdep_irq_work_exit (__work) do { } while (0)#endif #if defined(CONFIG_IRQSOFF_TRACER) || \
kernel/irq_work.c +2 -0
@@ -153,7 +153,9 @@ static void irq_work_run_list(struct lli*/ flags =atomic_fetch_andnot (IRQ_WORK_PENDING , &work->flags); +lockdep_irq_work_enter (work); work->func (work); +lockdep_irq_work_exit (work);/* * Clear the BUSY bit and return to the free state if * no-one else claimed it meanwhile.
kernel/rcu/tree.c +1 -0
@@ -1113,6 +1113,7 @@ static int rcu_implicit_dynticks_qs(stru !rdp->rcu_iw_pending && rdp->rcu_iw_gp_seq != rnp->gp_seq && (rnp->ffmask & rdp->grpmask)) {init_irq_work (&rdp->rcu_iw, rcu_iw_handler); +atomic_set (&rdp->rcu_iw.flags,IRQ_WORK_HARD_IRQ ); rdp->rcu_iw_pending = true; rdp->rcu_iw_gp_seq = rnp->gp_seq;irq_work_queue_on (&rdp->rcu_iw, rdp->cpu);
kernel/time/tick-sched.c +1 -0
@@ -245,6 +245,7 @@ static void nohz_full_kick_func(struct i static DEFINE_PER_CPU(struct irq_work, nohz_full_kick_work) = { .func = nohz_full_kick_func, + .flags =ATOMIC_INIT (IRQ_WORK_HARD_IRQ ), };/*
[tip: locking/core] lockdep: Annotate irq_work
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 49915ac35ca7b07c54295a72d905be5064afb89e Gitweb: https://git.kernel.org/tip/49915ac35ca7b07c54295a72d905be5064afb89e Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:26:03 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:24 +01:00
lockdep: Annotate irq_work
Mark irq_work items with IRQ_WORK_HARD_IRQ which should be invoked in hardirq context even on PREEMPT_RT. IRQ_WORK without this flag will be invoked in softirq context on PREEMPT_RT.
Set ->irq_config to 1 for the IRQ_WORK items which are invoked in softirq context so lockdep knows that these can safely acquire a spinlock_t.
--- include/linux/irq_work.h | 2 ++ include/linux/irqflags.h | 13 +++++++++++++ kernel/irq_work.c | 2 ++ kernel/rcu/tree.c | 1 + kernel/time/tick-sched.c | 1 + 5 files changed, 19 insertions(+)
include/linux/irq_work.h +2 -0
@@ -18,6 +18,8 @@/* Doesn't want IPI, wait for tick: */ #define IRQ_WORK_LAZY BIT(2) +/* Run hard IRQ context, even on RT */ +#define IRQ_WORK_HARD_IRQ BIT(3)#define IRQ_WORK_CLAIMED (IRQ_WORK_PENDING | IRQ_WORK_BUSY)
include/linux/irqflags.h +13 -0
@@ -69,6 +69,17 @@ do { \ current->irq_config =0 ; \ } while (0) +# define lockdep_irq_work_enter (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 1; \ + } while (0) +# define lockdep_irq_work_exit (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 0; \ + } while (0) +#else # define trace_hardirqs_on () do { } while (0)# define trace_hardirqs_off () do { } while (0)
@@ -83,6 +94,8 @@ do { \# define lockdep_softirq_exit () do { } while (0)# define lockdep_hrtimer_enter (__hrtimer) do { } while (0)# define lockdep_hrtimer_exit (__hrtimer) do { } while (0) +# define lockdep_irq_work_enter (__work) do { } while (0) +# define lockdep_irq_work_exit (__work) do { } while (0)#endif #if defined(CONFIG_IRQSOFF_TRACER) || \
kernel/irq_work.c +2 -0
@@ -153,7 +153,9 @@ static void irq_work_run_list(struct llist_head *list)*/ flags =atomic_fetch_andnot (IRQ_WORK_PENDING , &work->flags); +lockdep_irq_work_enter (work); work->func (work); +lockdep_irq_work_exit (work);/* * Clear the BUSY bit and return to the free state if * no-one else claimed it meanwhile.
kernel/rcu/tree.c +1 -0
@@ -1113,6 +1113,7 @@ static int rcu_implicit_dynticks_qs(struct rcu_data *rdp) !rdp->rcu_iw_pending && rdp->rcu_iw_gp_seq != rnp->gp_seq && (rnp->ffmask & rdp->grpmask)) {init_irq_work (&rdp->rcu_iw, rcu_iw_handler); +atomic_set (&rdp->rcu_iw.flags,IRQ_WORK_HARD_IRQ ); rdp->rcu_iw_pending = true; rdp->rcu_iw_gp_seq = rnp->gp_seq;irq_work_queue_on (&rdp->rcu_iw, rdp->cpu);
kernel/time/tick-sched.c +1 -0
@@ -245,6 +245,7 @@ static void nohz_full_kick_func(struct irq_work *work) static DEFINE_PER_CPU(struct irq_work, nohz_full_kick_work) = { .func = nohz_full_kick_func, + .flags =ATOMIC_INIT (IRQ_WORK_HARD_IRQ ), };/*
Frederic Weisbecker
maintainerRe: [tip: locking/core] lockdep: Annotate irq_work
Quoted 48 lines · On Sat, Mar 21, 2020 at 03:53:45PM -0000, tip-bot2 for Sebastian Andrzej…
The following commit has been merged into the locking/core branch of tip:
Commit-ID: 49915ac35ca7b07c54295a72d905be5064afb89e Gitweb: https://git.kernel.org/tip/49915ac35ca7b07c54295a72d905be5064afb89e Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:26:03 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:24 +01:00lockdep: Annotate
irq_workMark
irq_workitems withIRQ_WORK_HARD_IRQwhich should be invoked in hardirq context even onPREEMPT_RT.IRQ_WORKwithout this flag will be invoked in softirq context onPREEMPT_RT.Set ->irq_config to 1 for the
IRQ_WORKitems which are invoked in softirq context so lockdep knows that these can safely acquire aspinlock_t.Signed-off-by Sebastian Andrzej Siewior <[email protected]>Signed-off-by Thomas Gleixner <[email protected]>Signed-off-by Peter Zijlstra (Intel) <[email protected]>--- include/linux/irq_work.h | 2 ++ include/linux/irqflags.h | 13 +++++++++++++ kernel/irq_work.c | 2 ++ kernel/rcu/tree.c | 1 + kernel/time/tick-sched.c | 1 + 5 files changed, 19 insertions(+)include/linux/irq_work.h +2
-0@@ -18,6 +18,8 @@/* Doesn't want IPI, wait for tick: */ #define IRQ_WORK_LAZY BIT(2) +/* Run hard IRQ context, even on RT */ +#define IRQ_WORK_HARD_IRQ BIT(3)#define IRQ_WORK_CLAIMED (IRQ_WORK_PENDING | IRQ_WORK_BUSY)include/linux/irqflags.h +0
-0
include/linux/irqflags.h do { \ · line 75
Quoted 7 lines
include/linux/irqflags.h +4
-0@@ -69,6 +69,17 @@ do { \ current->irq_config =0 ; \ } while (0) +# define lockdep_irq_work_enter (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 1; \
So, irq_config == 1 means we are in a softirq? Are there other values for irq_config? In which case there should be enums or something? I can't find the patch that describes this.
Quoted 50 lines
include/linux/irqflags.h +9
-0+ } while (0) +# define lockdep_irq_work_exit (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 0; \ + } while (0) +#else # define trace_hardirqs_on () do { } while (0)# define trace_hardirqs_off () do { } while (0)@@ -83,6 +94,8 @@ do { \# define lockdep_softirq_exit () do { } while (0)# define lockdep_hrtimer_enter (__hrtimer) do { } while (0)# define lockdep_hrtimer_exit (__hrtimer) do { } while (0) +# define lockdep_irq_work_enter (__work) do { } while (0) +# define lockdep_irq_work_exit (__work) do { } while (0)#endif #if defined(CONFIG_IRQSOFF_TRACER) || \kernel/irq_work.c +2
-0@@ -153,7 +153,9 @@ static void irq_work_run_list(struct llist_head *list)*/ flags =atomic_fetch_andnot (IRQ_WORK_PENDING , &work->flags); +lockdep_irq_work_enter (work); work->func (work); +lockdep_irq_work_exit (work);/* * Clear the BUSY bit and return to the free state if * no-one else claimed it meanwhile. kernel/rcu/tree.c +1
-0@@ -1113,6 +1113,7 @@ static int rcu_implicit_dynticks_qs(struct rcu_data *rdp) !rdp->rcu_iw_pending && rdp->rcu_iw_gp_seq != rnp->gp_seq && (rnp->ffmask & rdp->grpmask)) {init_irq_work (&rdp->rcu_iw, rcu_iw_handler); +atomic_set (&rdp->rcu_iw.flags,IRQ_WORK_HARD_IRQ ); rdp->rcu_iw_pending = true; rdp->rcu_iw_gp_seq = rnp->gp_seq;irq_work_queue_on (&rdp->rcu_iw, rdp->cpu);kernel/time/tick-sched.c +0
-0
kernel/time/tick-sched.c static void nohz_full_kick_func(struct irq_work *work) · line 249
Quoted 5 lines
kernel/time/tick-sched.c +1
-0@@ -245,6 +245,7 @@ static void nohz_full_kick_func(struct irq_work *work) static DEFINE_PER_CPU(struct irq_work, nohz_full_kick_work) = { .func = nohz_full_kick_func, + .flags =ATOMIC_INIT (IRQ_WORK_HARD_IRQ ), };
I get why these need to be in hardirq but some basic explanations for ordinary mortals as to why those two specifically and not all the others (and there are many) would have been nice.
Thanks.
Quoted 2 lines
kernel/time/tick-sched.c +0
-0/*
Re: [tip: locking/core] lockdep: Annotate irq_work
Quoted 8 lines · Frederic Weisbecker
Quoted 8 lines
include/linux/irqflags.h +0
-0@@ -69,6 +69,17 @@ do { \ current->irq_config =0 ; \ }while (0 )
Quoted 8 lines
include/linux/irqflags.h do { \ · line 75
Quoted 4 lines
include/linux/irqflags.h +4
-0+# define lockdep_irq_work_enter (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 1; \So,
irq_config== 1 means we are in a softirq? Are there other values forirq_config? In which case there should be enums or something? I can't find the patch that describes this.
0 means as-is, 1 means threaded / sleeping locks are okay.
Quoted 4 lines
Quoted 4 lines
kernel/time/tick-sched.c +0
-0@@ -245,6 +245,7 @@ static void nohz_full_kick_func(struct irq_work *work)
Quoted 8 lines
kernel/time/tick-sched.c static void nohz_full_kick_func(struct irq_work *work) · line 249
Quoted 4 lines
kernel/time/tick-sched.c +1
-0static DEFINE_PER_CPU(struct irq_work, nohz_full_kick_work) = { .func = nohz_full_kick_func, + .flags =ATOMIC_INIT (IRQ_WORK_HARD_IRQ ), };I get why these need to be in hardirq but some basic explanations for ordinary mortals as to why those two specifically and not all the others (and there are many) would have been nice.
Is the documentation patch in this series any good?
Quoted 1 line
Thanks.
Sebastian
Frederic Weisbecker
maintainerRe: [tip: locking/core] lockdep: Annotate irq_work
Quoted 18 lines · Sebastian Andrzej Siewior
Quoted 8 lines · Frederic Weisbecker
Quoted 8 lines
include/linux/irqflags.h +0
-0@@ -69,6 +69,17 @@ do { \ current->irq_config =0 ; \ }while (0 )Quoted 8 lines
include/linux/irqflags.h do { \ · line 75
Quoted 4 lines
include/linux/irqflags.h +4
-0+# define lockdep_irq_work_enter (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 1; \So,
irq_config== 1 means we are in a softirq? Are there other values forirq_config? In which case there should be enums or something? I can't find the patch that describes this.
Quoted 1 line
0 means as-is, 1 means threaded / sleeping locks are okay.
So that's the kind of comment we need :-)
Also how about current->irq_locking instead?
And something like:
enum {
IRQ_LOCKING_NO_SLEEP,
IRQ_LOCKING_CAN_SLEEP
}
Quoted 14 lines
Quoted 5 lines
Quoted 5 lines
kernel/time/tick-sched.c +0
-0@@ -245,6 +245,7 @@ static void nohz_full_kick_func(struct irq_work *work)Quoted 8 lines
kernel/time/tick-sched.c static void nohz_full_kick_func(struct irq_work *work) · line 249
Quoted 4 lines
kernel/time/tick-sched.c +1
-0static DEFINE_PER_CPU(struct irq_work, nohz_full_kick_work) = { .func = nohz_full_kick_func, + .flags =ATOMIC_INIT (IRQ_WORK_HARD_IRQ ), };I get why these need to be in hardirq but some basic explanations for ordinary mortals as to why those two specifically and not all the others (and there are many) would have been nice.
Quoted 1 line
Is the documentation patch in this series any good?
That describes the general rules but it doesn't tell anything about the details of this patch. Especially why RCU and nohz_full irq works in particular are special here and why it's fine for others to execute in softirq.
Thanks.
Quoted 3 lines
Quoted 1 line
Thanks.
Sebastian
Frederic Weisbecker
maintainerRe: [tip: locking/core] lockdep: Annotate irq_work
Quoted 23 lines · Frederic Weisbecker
Quoted 18 lines · Sebastian Andrzej Siewior
Quoted 8 lines · Frederic Weisbecker
Quoted 8 lines
include/linux/irqflags.h +0
-0@@ -69,6 +69,17 @@ do { \ current->irq_config =0 ; \ }while (0 )Quoted 8 lines
include/linux/irqflags.h do { \ · line 75
Quoted 4 lines
include/linux/irqflags.h +4
-0+# define lockdep_irq_work_enter (__work) \ + do { \ + if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\ + current->irq_config = 1; \So,
irq_config== 1 means we are in a softirq? Are there other values forirq_config? In which case there should be enums or something? I can't find the patch that describes this.Quoted 1 line
0 means as-is, 1 means threaded / sleeping locks are okay.
So that's the kind of comment we need :-)
Quoted 8 lines
Also how about
current->irq_lockinginstead?And something like:
enum {
IRQ_LOCKING_NO_SLEEP,
IRQ_LOCKING_CAN_SLEEP
}
Or current->irq_preemptible
enum {
IRQ_NEVER_PREEMPTIBLE,
IRQ_MAYBE_PREEMPTIBLE
}
Re: [tip: locking/core] lockdep: Annotate irq_work
In reply to Frederic WeisbeckerQuoted 11 lines · Frederic Weisbecker
Quoted 11 lines
Quoted 10 lines
kernel/time/tick-sched.c static void nohz_full_kick_func(struct irq_work *work) · line 249
Quoted 6 lines
kernel/time/tick-sched.c +1
-0@@ -245,6 +245,7 @@ static void nohz_full_kick_func(struct irq_work *work) static DEFINE_PER_CPU(struct irq_work, nohz_full_kick_work) = { .func = nohz_full_kick_func, + .flags =ATOMIC_INIT (IRQ_WORK_HARD_IRQ ), };I get why these need to be in hardirq but some basic explanations for ordinary mortals as to why those two specifically and not all the others (and there are many) would have been nice.
Quoted 5 lines
Quoted 1 line
Is the documentation patch in this series any good?
That describes the general rules but it doesn't tell anything about the details of this patch. Especially why RCU and
nohz_fullirq works in particular are special here and why it's fine for others to execute in softirq.
Hmm. You need to know the details of the code. RCU is used in hardirq context, uses (carefully) raw_spinlock_t and so on.
If my memory serves me well in regard to the "nohz kick" part here NOHZ_FULL needs to observe the CPU if it idle or a task is running. If this is invoked as part of softirq, which is threaded, then it will never observe an idle CPU because there is always a task RUNNING with the softirq doing this callback.
Quoted 1 line
Thanks.
Sebastian
PATCH v3 20/20 lockdep: Add posixtimer context tracing bits
In reply to Thomas GleixnerFrom: Sebastian Andrzej Siewior <[email protected]>
Splitting run_posix_cpu_timers() into two parts is work in progress which is stuck on other entry code related problems. The heavy lifting which involves locking of sighand lock will be moved into task context so the necessary execution time is burdened on the task and not on interrupt context.
Until this work completes lockdep with the spinlock nesting rules enabled would emit warnings for this known context.
Prevent it by setting "->irq_config = 1" for the invocation of run_posix_cpu_timers() so lockdep does not complain when sighand lock is acquried. This will be removed once the split is completed.
--- include/linux/irqflags.h | 12 ++++++++++++ kernel/time/posix-cpu-timers.c | 6 +++++- 2 files changed, 17 insertions(+), 1 deletion(-)
include/linux/irqflags.h +12 -0
@@ -69,6 +69,16 @@ do { \ current->irq_config =0 ; \ } while (0) +# define lockdep_posixtimer_enter () \ + do { \ + current->irq_config = 1; \ + } while (0) + +# define lockdep_posixtimer_exit () \ + do { \ + current->irq_config = 0; \ + } while (0) +# define lockdep_irq_work_enter (__work) \ do { \ if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\
@@ -94,6 +104,8 @@ do { \# define lockdep_softirq_exit () do { } while (0)# define lockdep_hrtimer_enter (__hrtimer) do { } while (0)# define lockdep_hrtimer_exit (__hrtimer) do { } while (0) +# define lockdep_posixtimer_enter () do { } while (0) +# define lockdep_posixtimer_exit () do { } while (0)# define lockdep_irq_work_enter (__work) do { } while (0)# define lockdep_irq_work_exit (__work) do { } while (0)#endif
kernel/time/posix-cpu-timers.c +5 -1
@@ -1126,8 +1126,11 @@ void run_posix_cpu_timers(void)if (!fastpath_timer_check (tsk))return ; -if (!lock_task_sighand (tsk, &flags)) +lockdep_posixtimer_enter (); +if (!lock_task_sighand (tsk, &flags)) { +lockdep_posixtimer_exit ();return ; + }/* * Here we take off tsk->signal->cpu_timers[N] and * tsk->cpu_timers[N] all the timers that are firing, and
@@ -1169,6 +1172,7 @@ void run_posix_cpu_timers(void)cpu_timer_fire (timer);spin_unlock (&timer->it_lock); } +lockdep_posixtimer_exit (); }/*
[tip: locking/core] lockdep: Add posixtimer context tracing bits
The following commit has been merged into the locking/core branch of tip:
The following commit has been merged into the locking/core branch of tip:
Commit-ID: d53f2b62fcb63f6547c10d8c62bca19e957b0eef Gitweb: https://git.kernel.org/tip/d53f2b62fcb63f6547c10d8c62bca19e957b0eef Author: Sebastian Andrzej Siewior <[email protected]> AuthorDate: Sat, 21 Mar 2020 12:26:04 +01:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Sat, 21 Mar 2020 16:00:25 +01:00
lockdep: Add posixtimer context tracing bits
Splitting run_posix_cpu_timers() into two parts is work in progress which is stuck on other entry code related problems. The heavy lifting which involves locking of sighand lock will be moved into task context so the necessary execution time is burdened on the task and not on interrupt context.
Until this work completes lockdep with the spinlock nesting rules enabled would emit warnings for this known context.
Prevent it by setting "->irq_config = 1" for the invocation of run_posix_cpu_timers() so lockdep does not complain when sighand lock is acquried. This will be removed once the split is completed.
--- include/linux/irqflags.h | 12 ++++++++++++ kernel/time/posix-cpu-timers.c | 6 +++++- 2 files changed, 17 insertions(+), 1 deletion(-)
include/linux/irqflags.h +12 -0
@@ -69,6 +69,16 @@ do { \ current->irq_config =0 ; \ } while (0) +# define lockdep_posixtimer_enter () \ + do { \ + current->irq_config = 1; \ + } while (0) + +# define lockdep_posixtimer_exit () \ + do { \ + current->irq_config = 0; \ + } while (0) +# define lockdep_irq_work_enter (__work) \ do { \ if (!(atomic_read(&__work->flags) & IRQ_WORK_HARD_IRQ))\
@@ -94,6 +104,8 @@ do { \# define lockdep_softirq_exit () do { } while (0)# define lockdep_hrtimer_enter (__hrtimer) do { } while (0)# define lockdep_hrtimer_exit (__hrtimer) do { } while (0) +# define lockdep_posixtimer_enter () do { } while (0) +# define lockdep_posixtimer_exit () do { } while (0)# define lockdep_irq_work_enter (__work) do { } while (0)# define lockdep_irq_work_exit (__work) do { } while (0)#endif
kernel/time/posix-cpu-timers.c +5 -1
@@ -1126,8 +1126,11 @@ void run_posix_cpu_timers(void)if (!fastpath_timer_check (tsk))return ; -if (!lock_task_sighand (tsk, &flags)) +lockdep_posixtimer_enter (); +if (!lock_task_sighand (tsk, &flags)) { +lockdep_posixtimer_exit ();return ; + }/* * Here we take off tsk->signal->cpu_timers[N] and * tsk->cpu_timers[N] all the timers that are firing, and
@@ -1169,6 +1172,7 @@ void run_posix_cpu_timers(void)cpu_timer_fire (timer);spin_unlock (&timer->it_lock); } +lockdep_posixtimer_exit (); }/*
Quoted 2 lines · Thomas Gleixner
This is the third and hopefully final version of this work. The second one can be found here:
Would you rather I send in a separate series with the kvm changes, or should I just send a v2 with the fixes here again?
Thanks,
Davidlohr
Quoted 7 lines · Davidlohr Bueso
Quoted 2 lines · Thomas Gleixner
This is the third and hopefully final version of this work. The second one can be found here:
Would you rather I send in a separate series with the kvm changes, or should I just send a v2 with the fixes here again?
Send a separate series please. These nested threads are hard to follow.
Thanks,
tglx