Programming

Hello all, I am trying to create n child processes and control them from a parent process; say make child 3 print its pid and then child 5 do the same and some other stuff. Is there a way to accomplishing this after all the child processes are created via a call to fork().
Thank you,
FG

> Is there a way to accomplishing this after all the child processes are created via a call to fork().

No. Unless child and parent explicitly define a protocol to control such things on a voluntary basis, e.g. the parent to could send a certain signal to a child in order to have it react in a pre-defined manner.

Given that all your target processes are children, the parent could create a pipe with each of them and send a signal whenever you've just sent a command down the pipe. The children would check the state of the pipe whenever the signal arrives and take appropriate actions. Of course, this might not be the best way depending on your requirements (apparently you don't seem to know what you want either), but it's a pretty asynchronous one.

Other than that, you could in theory kludge your own machine code into the child's text segment e.g. by using ptrace() or /proc/<pid>/mem or somesuch, but this is hardly applicable, so I'd guess you want to do the former.

I gave it some thought, and based on your reply I would like to do the following: "the parent could create a pipe with each of them and send a signal whenever you've just sent a command down the pipe"
-- I have to guarantee that when I send the command down the pipe and then the signal, this is all done atomically, I would also like to use semaphores to guard this section of the code, I do not want to travel the disabling interrupts route or busy waiting.
If this possible can someone point me to some sample code or resources for all tasks, creation of pipes and writing commands to it, signaling the process and using semaphores.
Thank you.
FI

> I have to guarantee that when I send the
> command down the pipe and then the signal,
> this is all done atomically

I assume that by ``atomically'', you mean that every receipt of a signal indicates the availability of exactly one new command and that no signals can be lost.

First of all, you should be familair with signal handling in general. If you are not, you should read the sigaction(2) manual help page to begin with. Another question is what your children are doing while not serving commands of the parent. Because of the very limited things you can do within a signal handler (usually, you should not do more than set a flag), the way you handle requests will depend greatly upon this.

If they are not doing anything, you could simply call pause(), install a signal handler which does not restart interrupted system calls (sa_flags = 0 with sigaction()) and handle everything after pause() returns with errno = EINTR. Otherwise, you would have to integrate some kind of flag into your child's main loop which is checked on a regular basis and which is set by the signal handler.

> I would also like to use semaphores to guard
> this section of the code, I do not want to
> travel the disabling interrupts route or busy waiting.

The signal being handled can be blocked while your signal handler is executing, but this could lead to signal loss if the parent sends more than one signal before the child gets to handle it. If your target operating system(s) support(s) the POSIX realtime extension function sigqueue(), you could use that instead of bothering with semaphores to avoid loss (alas, the various BSD's do not have this function, Linux and UNIX(R) branded systems do, however).

Of course write()'s of less than 512 bytes blocks by the parent are guaranteed to take place atomically already, so you could equally well ignore lost signals and read all commands there are whenever you receive a signal.

> If this possible can someone point me to
> some sample code or resources for all
> tasks, creation of pipes and writing
> commands to it, signaling the process and
> using semaphores.

This page seems like a good overview:

http://www.cs.cf.ac.uk/Dave/C/CE.html

I also recommend the excellent book ``Advanced Programming in the UNIX Environment'' by Richard Stevens.

Thank you for all your suggestions and resources, just some insight into the problem I am trying to solve, I have to create n process and print the process number to a file m times; this is a sample:
% a.out 5 3 temp

should result in temp having the following contents:
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5

Can you think of another solution other than the possibilities discussed.
Thank you,
FG

In other words, the children are doing nothing while waiting for the parent's notification. I agree that you will need a semaphore then, because the order in which signals are handled cannot be enforced in a reliable manner without resorting to changing scheduling policies, which is definitely not justified in this case.

I would probably do this:
Have each child install a signal handler for SIGUSR1, without restarting interrupted system calls. Have a loop calling pause() for the desired number of times the PID shall be written. After the parent has signaled the current child, it goes to sleep on a semaphore. After the child has written its PID to the file, it awakes the parent by incrementing the semaphore and calls pause() again. The parent goes on to signal the next child, and so on. Good luck

Thank you for all your help, I will be coding this weekend.