run-pass/issue-10626.rs goes nuts

[vmx]

On my machine the run-pass/issue-10626.rs goes nuts. It takes all my memory (8GB RAM, with a few things running, but not really much) and then started to swap (another 8GB then my disk was full).

When I ps aux I can see more and more processes called x86_64-unknown-linux-gnu/test/run-pass/issue-10626.stage2-x86_64-unknown-linux-gnu spinning up. The highest number I saw before it got very unresponsive was around 2800 processes.

All this was a make check on a recent master 69186efc199d48afca9427e448363212b0a59454. I had one of my own commits on top of that, but I really don't think that commit can cause this issue (I currently rerun with a clean master though).

[alexcrichton]

Hm, this would happen if the child doesn't see that it's a child (args isn't passed correctly maybe?).

Out of curiosity, does this modification to the program pass for you?

use std::os;                                           
use std::io::process;                                  

fn main () {                                           
    let args = os::args();                             
    if args.len() > 1 && args[1] == ~"child" {         
        for _ in range(0, 1000) {                      
            error!("hello?");                          
        }                                              
        for _ in range(0, 1000) {                      
            println!("hello?");                        
        }                                              
    }                                                  

    let args = [~"child"];                            
    let config = process::ProcessConfig {              
        program : args[0].as_slice(),                  
        args : args,                             
        env : None,                                    
        cwd : None,                                    
        io : []                                        
    };                                                 

    let mut p = process::Process::new(config).unwrap();
    println!("{}", p.wait());                          
}                                                      

[vmx]

I get:

task '<main>' failed at 'Unhandled condition: io_error: io::IoError{kind: OtherIoError, desc: "no such file or directory", detail: None}', /home/vmx/src/rust/rust/src/libstd/condition.rs:131

[vmx]

When I rename the let args = [~"child"]; to args2 it runs, without error, but has the same problem as the original version.

[vmx]

I shouldn't code when I'm tired. When I rename the let args = [~"child"]; to args2 and replace only the args in the ProcessConfig but leave the program with the original args, then it runs but has the original problem. When I also replace the program with args2, I get the runtime error as mentioned above.

[alexcrichton]

Oh sorry I didn't realize that things were getting shadowed. Can you print the contents of os::args() to see what's getting passed to the children?

[vmx]

When I add a println!("args: {:?}", os::args()); at the beginning of fn main() the output is:

$ /tmp/vmx-issue-10626 
args: ~[~"/tmp/vmx-issue-10626"]

[alexcrichton]

I'm more interested in what the children are printing, you'll probably have to set it up such that they inherit the stdio/stderr file descriptors.

[vmx]

BTW: I can confirm that the issue is also there on a clean master (commit 693ec73).

[vmx]

After some IRC discussion the conclusion was that it needs more investigation. Here's the code to see what the children print out. I've commented the original println! and error! out to see a bit clearer what the arguments of the children are.

use std::os;
use std::io::process;
use std::io::process::InheritFd;

fn main () {
    println!("args: {:?}", os::args());

    let args = os::args();
    if args.len() > 1 && args[1] == ~"child" {
        //for _ in range(0, 1000) {
        //    error!("hello?");
        //}
        //for _ in range(0, 1000) {
        //    println!("hello?");
        //}
    }

    let io = [InheritFd(0), InheritFd(1), InheritFd(2)];
    let config = process::ProcessConfig {
        program : args[0].as_slice(),
        args : [~"child"],
        env : None,
        cwd : None,
        io : io
    };

    let mut p = process::Process::new(config).unwrap();
    println!("{}", p.wait());
}

The output for every child is then:

args: ~[~"./vmx-issue-10626", ~"child"]

I'm on Debian testing 64-bit.

[dwrensha]

Looks to me like the test just needs to put the rest of its body in an else branch, like this:

use std::os;
use std::io::process;

fn main () {
    let args = os::args();
    if args.len() > 1 && args[1] == ~"child" {
        for _ in range(0, 1000) {
            error!("hello?");
        }
        for _ in range(0, 1000) {
            println!("hello?");
        }
    } else {
        let config = process::ProcessConfig {
            program : args[0].as_slice(),
            args : [~"child"],
            env : None,
            cwd : None,
            io : []
        };

        let mut p = process::Process::new(config).unwrap();
        println!("{}", p.wait());
    }
}

[alexcrichton]

I'm... not sure how I didn't see that before. I'm also not entirely sure how this is passing at all today.

Regardless, thanks @dwrensha!

[vmx]

I can confirm that #10794 fixes this issue.