Forum: Ruby-core Feature Proposal: Dir.chdir Thread Safety

Db953d125f5cc49756edb6149f1b813e?d=identicon&s=25 richard s. (richard_s)
on 2014-04-29 17:25
(Received via mailing list)
Issue #9785 has been updated by Richard Schneeman.


It's come to my attention that this is fairly hardcoded into the OS
(changing CWD is a per-process operation rather than a per-thread one).
I do not have a proposed implementation for how to change directory
within a thread, perhaps we could take ideas from another language
allows this functionality if there are any.

----------------------------------------
Feature #9785: Feature Proposal: Dir.chdir Thread Safety
https://bugs.ruby-lang.org/issues/9785#change-46367

* Author: Richard Schneeman
* Status: Open
* Priority: Normal
* Assignee:
* Category: core
* Target version: current: 2.2.0
----------------------------------------
I am proposing that `Dir.chdir` with a block be local to the current
thread and any threads that are created inside of that block.
`FileUtils.cd` and `FileUtils.chdir` should also behave the same way.

Currently `Dir.chdir` will change the directory for the entire process.
This makes writing a program that modifies different directories in
threads very difficult. Here is some ruby code that demonstrates the
problem:

```ruby
# /tmp/code.rb

require 'fileutils'

FileUtils.mkdir_p("/tmp/foo")
FileUtils.mkdir_p("/tmp/bar")


threads = []
threads << Thread.new do
  Dir.chdir("/tmp/foo") do
    puts "Thread in Dir.chdir('/tmp/foo') pwd: #{`pwd`}"
  end
end


threads << Thread.new do
  puts "Thread without Dir.chdir        pwd: #{`pwd`}"
end

threads.map(&:join)
```

When you run it you get different results:

```
$ ruby /tmp/code.rb
Thread without Dir.chdir        pwd: /tmp
Thread in Dir.chdir('/tmp/foo') pwd: /private/tmp/foo

$ ruby /tmp/code.rb
Thread in Dir.chdir('/tmp/foo') pwd: /private/tmp/foo
Thread without Dir.chdir        pwd: /private/tmp/foo
```

This is because Dir.chdir is not limited to the scope of the block but
rather changes the working directory globally for the entire process
including different threads.

Threads in MRI are very good for reading and writing to the disk,
however many times a programmer wishes to read or write to disk they
will want to use `Dir.chdir`. The current behavior of `Dir.chdir`
prevents a programmer from changing directory inside of threads and can
be very confusing for anyone who does not know this behavior.

For a better programming experience either we can make `Dir.chdir`
thread aware, or introduce a new way to change the directory inside of a
new thread such as `Dir.threadsafe_chdir`, I believe the first option is
the best.
18813f71506ebad74179bf8c5a136696?d=identicon&s=25 Eric Wong (Guest)
on 2014-04-29 18:49
(Received via mailing list)
richard.schneeman@gmail.com wrote:
> It's come to my attention that this is fairly hardcoded into the OS
> (changing CWD is a per-process operation rather than a per-thread
> one). I do not have a proposed implementation for how to change
> directory within a thread, perhaps we could take ideas from another
> language allows this functionality if there are any.

Right, this is one of the reasons the *at family of syscalls
(openat, renameat, etc...) was introduced into POSIX.

Adding support for those might be good idea.  However, OS support
outside Linux/Solaris is probably still limited at the moment.

Linux also allows unsetting the CLONE_FS flag for cloned threads,
but that's completely unportable.
This topic is locked and can not be replied to.