In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
IntheLinuxkernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes aspinlock recursion warning asreported by Guenter Roeck.As far as Ican ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but Ihaven't done adetailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that asimple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of arace for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causesa spinlock recursion warning asreported by Guenter Roeck.As far asI can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")butI haven't donea detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note thata simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough ofa race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes aspinlock recursion warning asreported by Guenter Roeck.As far as Ican ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but Ihaven't done adetailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that asimple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of arace for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causesa spinlock recursion warning asreported by Guenter Roeck.As far asI can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")butI haven't donea detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note thata simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough ofa race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes aspinlock recursion warning asreported by Guenter Roeck.As far as Ican ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but Ihaven't done adetailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that asimple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of arace for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causesa spinlock recursion warning asreported by Guenter Roeck.As far asI can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")butI haven't donea detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note thata simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough ofa race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes aspinlock recursion warning asreported by Guenter Roeck.As far as Ican ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but Ihaven't done adetailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that asimple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of arace for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causesa spinlock recursion warning asreported by Guenter Roeck.As far asI can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")butI haven't donea detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note thata simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough ofa race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes aspinlock recursion warning asreported by Guenter Roeck.As far as Ican ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but Ihaven't done adetailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that asimple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of arace for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causesa spinlock recursion warning asreported by Guenter Roeck.As far asI can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")butI haven't donea detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note thata simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough ofa race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linuxkernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retainthe correct lock owner acrosstheswitchfrom 'prev' to 'next' tasks. This does rely oninterruptsremaining disabled for the entire duration ofthe switch.This condition is guaranteed for normal process creation and contextswitching between already running processes,because both 'prev' and'next' already haveinterrupts disabled intheir saved copies of thestatus register.The situation is different for newly createdkernel threads. The statusregister is set to PS_Sin copy_thread(), which does leavethe IPL at 0.Uponrestoring the 'next' thread's status register in switch_to() akaresume(), interruptsthen become enabled prematurely. resume() thenreturnsvia ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before thelock isreleasedin finish_task_switch() will find the lock already taken,with thecurrent task as lockowner. This causes a spinlock recursion warningasreported byGuenter Roeck.As far as I can ascertain, this race has beenopened in commit533e6903bea0 ("m68k: splitret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernelhistory so it may wellpredate that commit.Interrupts cannot bedisabledin the saved status register copy forkernel threads(init will complain about interrupts disabled whenfinally starting user space). Disable interruptstemporarily whenswitching thetasks' registersets in resume().Note that a simple oriw 0x700,%sr after restoring sr is notenough here- this leaves enough of arace forthe 'spinlock recursion'warning tostillbe observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
IntheLinux kernel, thefollowing vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correctlock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabledfor the entire duration of the switch.This condition isguaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies ofthestatus register.Thesituation is different for newly created kernel threads. The statusregister is set toPS_S in copy_thread(), which does leave the IPL at0.Upon restoring the next threads status registerin switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns viaret_from_kernel_thread() and schedule_tail() where runqueuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lockalreadytaken, with thecurrent task as lock owner. This causes a spinlockrecursion warning asreportedby Guenter Roeck.As far as I can ascertain, thisrace has beenopened in commit533e6903bea0 ( m68k: split ret_from_fork(),simplify kernel_thread() )but I haven t done adetailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabledin the saved status register copy forkernel threads (init willcomplainabout interrupts disabled whenfinally starting userspace). Disable interrupts temporarily whenswitching the tasks register sets inresume().Note thata simple oriw 0x700,%sr afterrestoring sr is notenough herethis leaves enough of a race for the spinlock recursion warningtostill be observed.Tested on ARAnyMand qemu(Quadra 800 emulation).The Linuxkernel CVE teamhas assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough herethis leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In theLinux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In theLinux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes aspinlock recursion warning asreported by Guenter Roeck.As far as Ican ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but Ihaven't done adetailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that asimple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of arace for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causesa spinlock recursion warning asreported by Guenter Roeck.As far asI can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")butI haven't donea detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note thata simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough ofa race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
Inthe Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
Inthe Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from prev to next tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both prev and next already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the next thread s status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ( m68k: split ret_from_fork(), simplify kernel_thread() )but I haven t done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the spinlock recursion warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).
| linux | | https://git.kernel.org/linus/da89ce46f02470ef08f0f580755d14d547da59ed | https://git.kernel.org/linus/533e6903bea0440816a0f517b0845ccea4cc7917 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明:
In the Linux kernel, the following vulnerability has been resolved:m68k: Fix spinlock race in kernel thread creationContext switching does take care to retain the correct lock owner acrossthe switch from 'prev' to 'next' tasks. This does rely on interruptsremaining disabled for the entire duration of the switch.This condition is guaranteed for normal process creation and contextswitching between already running processes, because both 'prev' and'next' already have interrupts disabled in their saved copies of thestatus register.The situation is different for newly created kernel threads. The statusregister is set to PS_S in copy_thread(), which does leave the IPL at 0.Upon restoring the 'next' thread's status register in switch_to() akaresume(), interrupts then become enabled prematurely. resume() thenreturns via ret_from_kernel_thread() and schedule_tail() where run queuelock is released (see finish_task_switch() and finish_lock_switch()).A timer interrupt calling scheduler_tick() before the lock is releasedin finish_task_switch() will find the lock already taken, with thecurrent task as lock owner. This causes a spinlock recursion warning asreported by Guenter Roeck.As far as I can ascertain, this race has been opened in commit533e6903bea0 ("m68k: split ret_from_fork(), simplify kernel_thread()")but I haven't done a detailed study of kernel history so it may wellpredate that commit.Interrupts cannot be disabled in the saved status register copy forkernel threads (init will complain about interrupts disabled whenfinally starting user space). Disable interrupts temporarily whenswitching the tasks' register sets in resume().Note that a simple oriw 0x700,%sr after restoring sr is not enough here- this leaves enough of a race for the 'spinlock recursion' warning tostill be observed.Tested on ARAnyM and qemu (Quadra 800 emulation).The Linux kernel CVE team has assigned CVE-2024-38613 to this issue.