2

This is a simplified example:

script1

#!/bin/bash
./script2

script2

#!/bin/bash
foo() {
  parent_script=$(ps -o comm= $PPID)
  echo "Parent script: $parent_script" > log
}
foo &

Contents of log (after running script1):

Parent script:

I can get around this either by making the function a non-background one or by getting the parent script name outside the function and passing it as an argument:

script2

#!/bin/bash
foo() {
  echo "Parent script: $1" > log
}

parent_script=$(ps -o comm= $PPID)
foo "$parent_script" &

Contents of log (after running script1):

Parent script: script1

To make things stranger, if I just add a sleep 1 after the foo & line in the original script2, I also get the expected result:

#!/bin/bash
foo() {
  parent_script=$(ps -o comm= $PPID)
  echo "Parent script: $parent_script" > log
}
foo &
sleep 1

However I'd like to know 1) why does the first example not work, 2) is there a way to get the parent script name from inside the background function?

Improve this question
6
  • @JayCravens presumably, the idea is to find out the name, I don't think we can assume the name of the script will be known. More importantly, that would find all running instances of script1 (I think you meant pgrep script1), not only the one which launched script2. There could be hundreds of them running in parallel. Commented May 31, 2024 at 13:59
  • 1
    What is even weirder, AndroidX, is that if you add sleep 1 after the foo & line in script2, it works as expected! Some kind of weird race condition? Commented May 31, 2024 at 14:13
  • Indeed it works.. no idea what's happening though. Commented May 31, 2024 at 14:28
  • I get the same behavior (nothing printed at first, but expected output with the addition of the sleep 1 command) in dash and zsh. Commented May 31, 2024 at 14:57
  • It has to be some sort of race condition. I also get it to work if instead of sleep 1, I add seq 1 120000000 > /dev/null which takes around a second to run on my machine. In contrast, seq 1 12000 > /dev/null, which takes around 0.004s makes no difference. So we seem to need something that takes at least a second or so after the backgrounded function in order for it to work. Commented May 31, 2024 at 15:11

2 Answers 2

Reset to default
2

Addressing why the sleep 1 works ...

For the sample script there's a good chance the parent process completes/exits before the child process can spawn a subshell to run the ps. (spawning a subshell does take some amount of time)

At the point when the child process finally runs the ps it finds the parent process no longer exists.

The sleep 1 is going to keep the parent process active long enough for the child process to a) spawn a subshell and b) run a 'successful' ps.

There is no problem inherent in the fact that the function is sent to the background, the issue is that the script does nothing else so it will have exited by the time the function runs the ps. As such, if the script had more jobs to do, ensuring that it would still be running when the function was executed, the function would work just fine even in the background.

Conclusion: there is no way to make this work in the background without adding more steps to the main script since the parent will always exit before the ps can be run when this is sent to the background.

Improve this answer
5
  • "this does not address OP's original question" - I think it answers the "why" part. Commented May 31, 2024 at 15:35
  • 1
    Yeah, I think it addresses the original question perfectly. You explain why their attempt didn't work and also, by implication, answer the second question @AndroidX: no, there is no way to make this work in the background without adding more steps to the main script since the parent will always exit before the ps can be run when this is sent to the background. Commented May 31, 2024 at 15:40
  • @AndroidX / @terdon I was referring to the subject Get name of parent script from a background function; feel free to update the answer as needed for clarity; regards Commented May 31, 2024 at 15:41
  • 1
    @markp-fuso I think you've nailed it. There is no problem inherent in the fact that the function is sent to the background, the issue is that the script does nothing else so it will have exited by the time the function runs the ps, as you explain. As such, if the script had more jobs to do, ensuring that it would still be running when the function was executed, the function would work just fine even in the background. So while I appreciate you're trying to do the right thing by making this a wiki post, I honestly don't think you should and you deserve to get the rep for this. Commented May 31, 2024 at 15:44
  • 1
    I've added @terdon 's comments and accepted the answer. Commented May 31, 2024 at 16:32
1

Another option for obtaining the parent's script name would be to capture $0 (name of script) while still inside the parent script.

This can then be passed to the child process either as a command line argument or via an exported variable, eg:

$ cat testme
#!/bin/bash

child1() { sleep 1; echo "child1 : $1"; }          # function references the parent's name via the command line argument
child2() { sleep 1; echo "child2 : ${parent}"; }   # function references the parent's name via the exported variable

export parent="$0"                                 # capture current script's name; export so child processes have access to the variable

child1 "${parent}" &                               # pass parent's name as command line argument
child2             &

Testing:

$ ./testme
$                                                  # parent script exits and we're presented with the command prompt
 child1 : ./testme                                 # 1 second later the child functions'
 child2 : ./testme                                 # output shows up in the terminal

$ ../temp/testme
$
child1 : ../temp/testme
child2 : ../temp/testme

Notice in both cases $0 includes a path component; if the path component is not desired we can use parameter substitution to strip off the path:

### replace this:

export parent="$0"

### with this:

export parent="${0##*/}"

NOTE: we could instead use export parent=$(basename "$0") but with parameter substitution there's no need to spawn a subshell (to capture the results of the basename call)

Testing:

$ ./testme
$
child1 : testme
child2 : testme

$ ../temp/testme
$ 
child1 : testme
child2 : testme

A couple benefits to this approach:

  • no need to spawn a subshell to capture the output from a ps call
  • the child process has access to the parent script's name even if the parent script completes/exits before the child process can reference the parent script's name
Improve this answer

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.