Question

我通过声明这是一项家庭作业来表达这一点，并且我在编写SIGCHLD处理程序时遇到困难。我需要访问子进程中的变量。

#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>


#define TEXT_LEN 10
#define NUM_RESCUE_PLOWS 4
#define NUM_VICTIMS_TO_RESCUE 40


/*  PURPOSE:  To keep trap of the number of victims that have been rescued.
 */
int numRescuedVictims = 0;



/*  PURPOSE:  To keep track of the process id's of the rescuing snow plows.
 */
pid_t plowPid[NUM_RESCUE_PLOWS];


/*  PURPOSE:  To note that at least one child plow has finished.  Reports the
 *process id and the number of victims rescued for each child plow.
 *'sigNum' tells the signal number.  No return value
 */
//  You may want to define a SIGCHLD listener here
//  It should have a loop that wait()s for children and
//  and prints how many victims each has rescued.
void listenSIGCHLD(int sig)
{
  int status;
  pid_t pidWait;
  while((pidWait = wait(&status)) > 0)
    printf("Plow %d rescued %d victim(s)", plowId, numVictimsRescued);
}


/*  PURPOSE:  To handle being informed of a rescued victim.  'sigNum' tells
 *signal number.  No return value.
 */
//  You may want to define a SIGUSR1 listener here
//  It increments 'numRescuedVictims' and prints the total number rescued victims
void listenSIGUSR1(int sig)
{
  numRescuedVictims += &numVictimsRescued;
  printf("We've rescued %d victims!" numRescuedVictims);
}


/*  PURPOSE:  To make 'NUM_RESCUE_PLOWS' processes to run 'rescuingPlow' to
 *rescue stuck victims, and then tell them to quit after all
 *'NUM_VICTIMS_TO_RESCUE' victims have been rescued.  Ignores parameters.
 *Returns 'EXIT_SUCCESS' to OS.
 */
int main ()
{

  //  I.  Applicability validity check:


  //  II.  Rescue victims:

  //  II.A.  Install 'SIGUSR1' handler:
  signal(SIGUSR1, listenSIGUSR1);

  // Install 'SIGUSR1' handler
  //  Install your SIGCHLD handler here
  signal(SIGCHLD, listenSIGCHLD);

  //  II.B.  Tell NUM_RESCUE_PLOWS plows to start rescuing the victims:

  int i;
  int myPid= getpid();

  for  (i = 0;  i < NUM_RESCUE_PLOWS;  i++)
    {
      //  Do a fork() and save it in plowPid[i]
      plowPid[i] = fork();
      //  If plowPid[i] is less than 0 then do:
      if(plowPid[i] < 0)
    {
      fprintf(stderr,"Dude, your system is WAY to busy to play rescuer!\n");
      return(EXIT_FAILURE);
    }

      //  If plowPid[i] is equal to 0 then do:
      else if(plowPid[i] == 0)
    {
      char pidText[TEXT_LEN];
      char indexText[TEXT_LEN];
    }
      snprintf(pidText,TEXT_LEN,"%d",myPid);
      snprintf(indexText,TEXT_LEN,"%d",i);
      execl("./rescuingPlow","rescuingPlow",pidText,indexText,NULL);
      fprintf(stderr,"Dude, somebody stole my plow!!\n");
      return(EXIT_FAILURE);
    }


  //  II.C.  Wait until all victims have been rescued:

  while  (numRescuedVictims < NUM_VICTIMS_TO_RESCUE)
    {
      sleep(1);
      printf("Searching for victims . . .\n");
    }


  //  III.  Finished:

  //  Loop to send SIGTERM to all NUM_RESCUE_PLOWS plow processes
  for (int i = 0; i < NUM_RESCUE_PLOWS; i++)
    {
      kill(plowPid[i], SIGTERM);
    }
  int toSleep= NUM_RESCUE_PLOWS;

  //  sleep() can be interrupted by SIGCHLD.  Whenever it is interrupted
  //  it returns the number of seconds that still remain on its alarm
  //  clock.  Let's wait until it has slept its full amount incase it
  //  was prematured interrupted by SIGCHLD.
  do
    {
      toSleep= sleep(toSleep);
    }
  while  (toSleep > 0);

  printf("Ready for the NEXT snow storm!\n");
  return(EXIT_SUCCESS);
}

`

这就是最终会产生的进程。虽然我还没有完成这项工作。

/*
 *  rescuingPlow.c
 *
 *  Compile with $ gcc rescuingPlow.c -o rescuingPlow
 */
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>


/*  PURPOSE:  To keep track of the number of victims that this process
 *  rescued.
 */
int numVictimsRescued   = 0;



/*  PURPOSE:  To return the number of victims rescued to the OS.  'sigNum'
 *  tells the signal number.  No return value.
 */
//  You may want to write a SIGTERM handling function
//  that returns to the OS 'numVictimsRescued'.



/*  PURPOSE:  To rescue victims at random intervals and inform parent process
 *  by sending it SIGUSR1 until receiving SIGTERM.  First parameter (after
 *  program name) tells parent's process id.  Second parameter tells this
 *  plow's index.
 */
int main    (int argc, char* argv[])
{

  //  I.  Applicability validity check:

  pid_t parentPID;
  int   plowId;

  if  (argc < 3)
  {
    fprintf(stderr,"USAGE: rescuingPlow <parentPID> <plowId>\n");
    return(EXIT_FAILURE);
  }

  parentPID = atoi(argv[1]);
  plowId    = atoi(argv[2]);


  //  II.  Rescuing victims until told to stop:

  //  II.A.  Install signal handler:

  //  Install your SIGTERM handler here
  srand(plowId);  //  Uniquely initialize random number generator so they act independently of each other


  //  II.B.  Rescue victims:

  //  Write an endless loop that:
  //  (1) Does 'sleep((rand() % 6) + 1);'
  //  (2) Increments 'numVictimsRescued'
  //  (3) Does 'printf("Plow %d rescued %d victim(s)!\n",plowId,numVictimsRescued);'
  //  (4) Send 'SIGUSR1' to 'parentPID'


  //  III.  Finished:

  return(EXIT_SUCCESS);
}

我不完全确定我要去哪里或如何应对。我非常有信心能解决现存的大多数其他问题。

Answer 1

在不使用某些IPC机制的情况下，子进程只能将8位的值传递给父进程。

子项将这8位作为参数发送给exit()，并由父项通过将宏WEXITSTATUS()应用于成功返回的status的值来接收致电wait()或waitpid()。有关详细信息，请参阅man 2 exit和man 2 wait。

如果我没记错的话，8位是标准定义的最小值。某些实现可能允许更多位。

<强>更新

如何使用wait()：

的示例

int child_exit_code = -1;
int status = -1;
pid_t pid = wait(&status);
if (-1 != pid)
  child_exit_code = WEXITSTATUS(status);

Answer 2

您可以使用shmget分配共享内存。

在分叉之前使用它，然后子节点和父节点都可以访问分配的内存孩子可以存储它想要的任何东西，父母会读它。

需要在SIGCHLD处理程序期间从子代访问变量

2 个答案: