[ruby-core:122121] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[ruby-core:122121] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[maciej.mensfeld (Maciej Mensfeld) via ruby-core]

Issue #21342 has been reported by maciej.mensfeld (Maciej Mensfeld).

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Open
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:122122] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[masterleep2 (Bill Lipa) via ruby-core]

Issue #21342 has been updated by masterleep2 (Bill Lipa).


Additionally, on macOS, the script crashes but then gets in a seemingly endless loop after printing the 'C level backtrace information' line, and can't be killed with ^C.

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-113275

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Open
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:122123] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[byroot (Jean Boussier) via ruby-core]

Issue #21342 has been updated by byroot (Jean Boussier).


Looks like we're missing a null check:

```
  * frame #0: 0x0000000100349cb4 miniruby`thread_mutex_remove(thread=0x0000000000000000, mutex=0x0000600001147f00) at thread_sync.c:225:12
    frame #1: 0x000000010033c1f0 miniruby`rb_mutex_unlock_th(mutex=0x0000600001147f00, th=0x0000000000000000, fiber=0x0000000122f0a9c0) at thread_sync.c:467:5
    frame #2: 0x0000000100349a9c miniruby`mutex_free(ptr=0x0000600001147f00) at thread_sync.c:132:27
    frame #3: 0x0000000100122bdc miniruby`rb_data_free(objspace=0x000000012380a200, obj=4349174720) at gc.c:1192:17
    frame #4: 0x0000000100122638 miniruby`rb_gc_obj_free(objspace=0x000000012380a200, obj=4349174720) at gc.c:1371:14

```

I suspec tthe thread was freed before the mutex.

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-113276

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Open
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:122124] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[byroot (Jean Boussier) via ruby-core]

Issue #21342 has been updated by byroot (Jean Boussier).


Looks like it's not that simple. This smells of memory corruption because we end up in this loop:

```c
-> 230 	    while (*keeping_mutexes && *keeping_mutexes != mutex) {
   231 	        // Move to the next mutex in the list:
   232 	        keeping_mutexes = &(*keeping_mutexes)->next_mutex;
   233 	    }
```

And at some point `->next_mutex` is a clearly wrong pointer (various low values such as `0xff`, `0x13`, etc). So I assume something else end up overwriting that memory.

All I can say is it still reproduce on `master`.


----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-113277

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Open
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:122979] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[luke-gru (Luke Gruber) via ruby-core]

Issue #21342 has been updated by luke-gru (Luke Gruber).

Backport changed from 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN to 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: REQUIRED

I created a PR here: https://github.com/ruby/ruby/pull/14262

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-114282

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Open
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: REQUIRED
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:123132] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[ioquatix (Samuel Williams) via ruby-core]

Issue #21342 has been updated by ioquatix (Samuel Williams).


Just for the sake of cross-referencing related issues: https://bugs.ruby-lang.org/issues/18818

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-114459

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Open
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: REQUIRED
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:123341] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[k0kubun (Takashi Kokubun) via ruby-core]

Issue #21342 has been updated by k0kubun (Takashi Kokubun).

Backport changed from 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: REQUIRED to 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: DONE

ruby_3_4 commit:4306c9048fb674d24b92dc46b6746a4749564147 merged revision(s) commit:62430c19c9f1ab49429cebe65f30588472648c95.

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-114713

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Closed
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: DONE
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:123343] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[k0kubun (Takashi Kokubun) via ruby-core]

Issue #21342 has been updated by k0kubun (Takashi Kokubun).

Backport changed from 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: DONE to 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: REQUIRED

Reverted the ruby_3_4 backport since it failed the CI.

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-114715

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Closed
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: REQUIRED
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:123344] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[k0kubun (Takashi Kokubun) via ruby-core]

Issue #21342 has been updated by k0kubun (Takashi Kokubun).


I guess it was due to a wrong conflict resolution. I'll attempt to backport it again.

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-114716

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Closed
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: REQUIRED
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:123345] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[k0kubun (Takashi Kokubun) via ruby-core]

Issue #21342 has been updated by k0kubun (Takashi Kokubun).

Backport changed from 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: REQUIRED to 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: DONE

ruby_3_4 commit:264b2d78c366491834c9ce4499a4ad7b7564b89d.

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-114717

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Closed
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: DONE
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/

[ruby-core:123396] [Ruby Bug#21342] Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC

[nagachika (Tomoyuki Chikanaga) via ruby-core]

Issue #21342 has been updated by nagachika (Tomoyuki Chikanaga).

Backport changed from 3.2: UNKNOWN, 3.3: REQUIRED, 3.4: DONE to 3.2: UNKNOWN, 3.3: DONE, 3.4: DONE

ruby_3_3 commit:05f93fe6dc6f99fd2f728dd3c85dca944f1f4ba1 merged revision(s) commit:62430c19c9f1ab49429cebe65f30588472648c95.

----------------------------------------
Bug #21342: Segfault: invalid keeping_mutexes when using Mutex in Thread then Fiber after GC
https://bugs.ruby-lang.org/issues/21342#change-114767

* Author: maciej.mensfeld (Maciej Mensfeld)
* Status: Closed
* ruby -v: 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
* Backport: 3.2: UNKNOWN, 3.3: DONE, 3.4: DONE
----------------------------------------
Ruby crashes with a `[BUG] invalid keeping_mutexes error` when attempting to GC locked mutex that was used in a Thread within a Fiber context after garbage collection. The error indicates an attempt to unlock a mutex that is not locked, suggesting a state management issue with mutexes across Thread and Fiber boundaries.

## Ruby Version

`ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]`

## Reproduce Process

``` ruby
# segv.rb

5.times do
  m = Mutex.new
  Thread.new do
    m.synchronize do
    end
  end.join
  Fiber.new do
    GC.start
    m.lock
  end.resume
end
```

1. Save the above code to a file (e.g., `segv.rb`)
2. Run with `ruby segv.rb`
3. The crash occurs intermittently - sometimes it crashes immediately, sometimes it hangs, once in a while it works

## Actual Result

The program crashes with the following error:
```
segv.rb: [BUG] invalid keeping_mutexes: Attempt to unlock a mutex which is not locked
ruby 3.4.3 (2025-04-14 revision d0b7e5b6a0) +PRISM [x86_64-linux]
```

whole segfault in the attached txt file.

Full crash backtrace shows the error originates from:
- `rb_threadptr_unlock_all_locking_mutexes` in thread.c:450
- `rb_thread_terminate_all` in thread.c:467

The crash suggests an issue in mutex state management during thread termination.

## Expected Result

The script should complete successfully without crashing. The mutex should be properly managed across Thread and Fiber contexts, and garbage collection should not interfere with mutex state.


---Files--------------------------------
crash.txt (23.4 KB)


-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/