Inter-Process Communication:Assigning Task to a Newly Spawned Process

By -

Assigning Task to a Newly Spawned Process

By now one thing should be obvious: if the child process is to execute some other code, then we should first identify that executable (the one we wish to see executed). For our example case, let us first generate such an executable. We compile a program entitled get_int.c with the command line cc get_int.c -o int.o. So, when int.o executes, it reads in an integer.

The program to get an integer :

image

image

Clearly, our second step is to have a process spawned and have it execute the program int.o. Unix offers a way of directing the execution from a specified code segment by using an exec command. In the program given below, we spawn a child process and populate its code segment with the program int.o obtained earlier. We shall entitle this

program as int_wait.c.

Program int_wait.c

image

image

The main point to note here is that the forked child process gets populated by the code of program int.o with the parent int_wait.c. Also, we should note the arguments communicated in the exec command line.

Before we discuss some issues related to the new execution environment, a short discussion on exec command is in order. The exec family of commands comes in several flavors. We may choose an exec command to execute an identified executable defined using a relative or absolute path name. The exec() command may use some other arguments as well. Also, it may be executed with or without the inherited execution environment.

Most Unix systems support exec commands with the description in Table 7.2. The example above raises a few obvious questions. The first one is: Which are the properties the child retains after it is populated by a different code segment? In Table 7.3 we note that the process ID and user ID of the child process are carried over to the implanted process. However, the data and code segments obtain new information. Though, usually, a child process inherits open file descriptors from the parent, the implanted process may have some restrictions based on file access controls.

With this example we now have a way to first spawn and then populate a child process with the code of an arbitrary process. The implanted process still remains a child process but has its code independent of the parent. A process may spawn any number of child processes. However, much ingenuity lies in how we populate these processes and what form of communication we establish amongst these to solve a problem.

clip_image002

Comments

Post a Comment

Popular posts from this blog

Introduction to Operating Systems:Early History: The 1940s and 1950s

By -
Early History: The 1940s and 1950s Operating systems have evolved over the last 60 years through several distinct phases or generations that correspond roughly to the decades (see the Operating Systems Thinking feature, Innovation).3 In the 1940s, the earliest electronic digital computers did not include operating systems.4, 5, 6 Machines of the time were so primitive that programmers often entered their machine-language programs one bit at a time on rows of mechanical switches. Eventually, programmers entered their machine-language programs on punched cards. Then, assembly languages—which used English-like abbreviations to represent the basic operations of the computer— were developed to speed the programming process. General Motors Research Laboratories implemented the first operating sys- tem in the early 1950s for its IBM 701 computer.7 The systems of the 1950s generally executed only one job at a time, using techniques that smoothed the transition between jobs to obtain maximu...
Read more

Memory Management:The Best Fit Policy, Memory Allocation and Fixed and Variable Partitions.

By -
Image
The Best Fit Policy: Memory Allocation The main criticism of first-fit policy is that it may leave many smaller holes. For instance, let us trace the allocation for process P5. It needs 2 units of space. At the time it moves into the main memory there is a hole with 2 units of space. But this is the last hole when we scan the main memory from the top (beginning). The first hole is 3 units. Using the first-fit policy process P5 is allocated this hole. So when we used this hole we also created a still smaller hole. Note that smaller holes are less useful for future allocations. In the best-fit policy we scan the main memory for all the available holes. Once we have information about all the holes in the memory then we choose the one which is closest to the size of the requirement of the process. In our example we allocate the hole with size 2 as there is one available. Table 4.3 follows best-fit policy for the current example. Also, as we did for the previous example, we shall again as...
Read more

Input Output (IO) Management:HW/SW Interface and Management of Buffers.

By -
Image
5.3 HW/SW Interface IO management requires that a proper set-up is created by an application on computer system with an IO device. An IO operation is a combination of HW and SW instructions as shown in Figure 5.8. Following the issuance of an IO command, OS kernel resolves it, and then communicates Figure 5.8: Communication with IO devices. with the concerned device driver. The device drivers in turn communicate with IO devices. The application at the top level only communicates with the kernel. Each IO request from an application results in generating the following: Naming or identification of the device to communicate. Providing device independent data to communicate; The kernel IO subsystem arranges for the following: The identification of the relevant device driver. We discuss device drivers in Section 5.3.1. Allocation of buffers. We discuss buffer management in Section 5.4. Reporting of errors. Tracking the device usage (is the device free, who is the current u...
Read more