JPH0447854B2 - - Google Patents

Description

[Detailed Description of the Invention] The present invention relates to a virtual computer system, and more specifically, to enable a child OS running under a parent OS to execute functions provided by the parent OS. This is related to the implementation method of the so-called handshake function of the OS.

A virtual computer is a device that allows multiple users using a computer system to create an environment on a single piece of hardware as if they own the computer system. (Hereafter, this will be referred to as the parent OS)
It is possible to run multiple operating systems (hereinafter referred to as child OS) under the .

Originally, a virtual computer system was able to run a child OS under a parent OS without making any changes to the existing OS.
In order to realize this, the following methods are used. In other words, taking advantage of the fact that among the instructions executed by the child OS, only certain privileged instructions command direct operations on resources on the real machine, privileged instructions are issued by the child OS. When this happens, an interrupt is generated to the parent OS, which allows the parent OS to analyze the issued privileged instruction and simulate the operation on the parent OS.

On the other hand, a child OS was originally created with the assumption that it would be executed on a real machine, so it generally has various OS functions built into it that allow real resources to be used effectively and in an easy-to-use manner. There is. However, when executed as a child OS, these functions have no practical meaning because the child OS cannot directly control real resources.

On the other hand, the parent OS also needs to be able to efficiently execute normal jobs, especially if it is implemented for an integrated virtual computer system, so it must have similar functionality to handle real machines efficiently. Therefore, when a child OS requests an operation related to a real resource, the child OS first
, and then similar management by the parent OS, resulting in double management, which is a big waste in terms of effective use of real resources and processing time.

If the parent OS and child OS are similar, by bypassing the functions of the child OS and directly using the functions of the parent OS, management overhead time can be reduced and the parent OS can effectively use all system resources. Management is often possible.

Hereinafter, bypassing the functions of the child OS and directly using the functions of the parent OS will be referred to as OS handshake.

However, traditional virtual machines are
If you try to create a virtual machine without making any changes to the OS, the only way to do it is to detect the issuance of a specific machine language instruction and simulate it at the machine language instruction level. specific OS functionality (usually defined as a macro instruction)
cannot be detected at the functional level, making it difficult to use the parent OS's functions at the macro level as described above.

Therefore, an object of the present invention is to provide a virtual machine system that can easily perform OS handshake, so that the same program can be used as a child OS regardless of whether it is executed as a child OS or not. When using,
The objective is to provide a virtual computer system that can realize an OS handshake function.

When executed on a child OS, the present invention requests handshake processing in the parent OS for the process specified in the operand part of the instruction, and when executed on the parent OS, a normal subroutine is executed. The first special machine language instruction that has a function equivalent to a branch instruction (hereinafter referred to as the enter instruction) to If it is not a handshake process, a second special machine language instruction with a function equivalent to a return instruction from a normal subroutine (hereinafter simply referred to as a return instruction), and the first special instruction issued by the child OS. It is started by a machine language instruction, performs the necessary processing for the parent OS to execute the function specified by the operand part of the first machine language instruction, calls the corresponding processing routine of the parent OS, and then executes the second machine language instruction. A handshake mechanism is provided to set the child OS to a state where the specified processing has been completed and request the child OS to restart after it is restarted with a special machine language instruction and performs the necessary post-processing. Yes, and when executed as a child OS, for a function that can be substituted by the function of the parent OS, a branch instruction, that is, a special enter instruction, to the subroutine that executes this function on the OS is sent in advance. By embedding, when this OS operates as a child OS, certain functions will be executed in the parent OS without processing in the child OS.
If it is not running as a child OS, as usual,
It is designed to be able to execute the functions of that OS. In other words, the same program can be used regardless of whether it is executed as a child OS. Next, one embodiment of the present invention will be explained with reference to FIG.

In this embodiment, a mode flip-flop 5 (hereinafter abbreviated as MFF) is provided to indicate whether the processor is executing a parent OS or a child OS. The VM switching mechanism 4 for switching the OS on the processor sets the MFF to the child OS mode when executing the child OS (MFF=1), and sets the MFF to the child OS mode when switching to the parent OS.
mode (MFF=0). Furthermore, this
The MFF is set to the parent OS mode (MFF=0) even when the processor is not operating in a virtual machine environment.

In this embodiment, in order to support OS handshake, the first
A special enter instruction is prepared as a special machine language, and a special return instruction is prepared as a second special machine language instruction for notifying the end of processing in the parent OS by handshake.

In this embodiment, it is assumed that all parameters for special enter commands are passed through the stack. That is, when a special enter instruction is executed, all the input data required by the called routine is prepared on the stack, and the output data required by the caller is prepared as a result of the called routine. It is assumed that the structure is such that all of the functions are placed on the stack and then the return is performed.

It is also assumed that return address information from a routine called by a special enter instruction is placed at a specific position on the stack.

This return address information includes the address to be executed next after the return instruction when the processing of the routine called by the special enter instruction is completed, as well as the address that this routine is executing handshake processing, i.e., the request from the child OS. This routine is being executed by
To indicate that control should be returned to the OS,
Special bits will be prepared. (Hereinafter, this will be referred to as the handshake bit.) The handshake bit is set to 1 while the handshake process is being executed.

The special return instruction has a field as an instruction code section with a value indicating that this instruction is a special return instruction, and the instruction decoding/execution mechanism 1 issues a special return instruction when executing the special return instruction. If the return address at a specific position in the process stack specifies an address on the child OS, the simulation mechanism will be activated; if the return address indicates the address of the parent OS, a normal return instruction will be executed. operates as

In the OS, when this OS is executed as a child OS, there is a subroutine that performs a specific process (hereinafter referred to as a candidate process) that may be processed by handshake in the parent OS. It is assumed that a special enter instruction is embedded in advance in place of the enter instruction to , and that the address of the subroutine is set in this operand.

In addition, for specific processes that may be executed as handshake processing of the child OS due to a handshake request from the child OS when executed as the parent OS, instead of a return instruction from a subroutine that performs this candidate process, , it is assumed that a special return instruction is pre-installed.

Further, in this embodiment, a handshake control table 3 is provided on the main memory in order to support handshake by the parent OS. Each entry j in this table has the identification number of the child OS (VMIDj) and the address of the subroutine on the child OS (ASPj) as keys, and the address of the corresponding subroutine on the parent OS (AMj) as the data part. .

This is the key part of the handshake control table 3.
The output of the VM identification register that holds the VM number currently being executed is applied to the VMID field, and the subroutine address field, which also constitutes the key part, indicates that the subroutine address is input to the handshake mechanism 2 from the operand of the special enter instruction. The data part is configured to be applied through the parent OS
The value of the above subroutine address field is applied to the handshake control mechanism 2.

It is assumed that handshake functions to be supported in the system are registered in advance in this table.

i.e. ASP on a particular VM specified by VMID
If the functionality of a particular subroutine specified by is supported by the subroutine specified by AM on the parent OS by handshake, then this
Assume that it is registered in any entry j in the handshake control table.

In this embodiment, the handshake mechanism 2
is realized by firmware, and receives a handshake request generated in the child OS, searches the handshake control table 3, sets the status of the parent OS and child OS, and transfers control to the corresponding preprocessor. It consists of a post-processing section that sets the status of the parent OS and child OS based on the handshake results.

The VM switching mechanism 4 is activated by the handshake mechanism 2, identifies the state of each VM, determines the OS to be executed next, and if it is necessary to switch the OS based on this determination, it changes the state of the currently running VM. By saving (rolling out) and restoring (rolling in) the state of the VM to be executed next, control is switched between the parent OS and child OS, or between child OSes.

At this time, if the next VM to be executed is a child OS, set the child OS mode (MFF = 1),
If it is the parent OS, it sets the parent OS mode (MFF=0) and also specifies the identification number (VMID) of the VM to be executed next.
Set in VM identification register 6.

In addition, in this example, each child
One process is prepared for each OS.

A process for which a handshake is requested from a child OS is handled by the parent OS as a process in response to a request from the corresponding support process. For this reason, when a handshake request is made from a child OS, the request from the child OS is converted into a form that can be identified by the parent OS as a request from a proxy process.
Upon completion of processing in the parent OS, processing is performed to convert the processing results performed on the support process into a format that can be recognized by the child OS.

Next, the operation in this embodiment will be explained. When a special enter instruction appears during program execution, that is, when the instruction decoding/execution mechanism 1 detects that the instruction to be executed is a special enter instruction, the following processing is performed.

If the processor is in parent OS mode (MFF=
0), the instruction decoding/execution mechanism 1 performs the same operation as a normal enter instruction. That is, a branch to the processor specified by the operand part of the instruction is performed.

When the processor is in child OS mode (MFF=
1), when a special enter command is detected, the command decoding and execution mechanism 1 activates the handshake mechanism 2. The activated handshake mechanism 2 performs the following processing.

The preprocessing section of the handshake mechanism 2 activated by the special enter command sets the child OS to an unexecutable state and uses the ID of the child OS that issued the special enter command set in the VM identification register 6.
The handshake control table 3 is searched using (VMID) and the value (ASP) of the operand part of the special enter command as keys, and an entry having the same value is found in the key part. If an entry j with the same value is found, that is, the process specified in the operand part (ASPj) of the special enter instruction on the child OS (VMIDj) is supported by the parent OS routine AMj by handshake processing. In this case, perform the following processing.

Here, first, the child that issued the special enter command
The parameters on the stack of the process that issued the special enter command are transferred to the stack of the OS-compatible proxy process, and the stack of the proxy process is updated.

Next, the handshake bit is set to 1 at the top of the stack of the proxy process as return address information to indicate that the return destination is the child OS, and the return address ARj is used as the return address after the special enter instruction. Set the instruction address, read the parent OS processing routine address AM ₀ registered in the data section of matching address j on the handshake control table 3, set it in the instruction counter area of the parent OS, and then start the substitute process. Set it to an executable state and start the VM switching mechanism 4.

The VM switching mechanism 4 is the currently running (child OS)
detects that the child OS has become unexecutable, saves the state of this child OS to main memory (rollout), determines the OS to be executed next, and
Load the OS state onto the processor (roll-in).

As a result, when the parent OS is executed, the delegated process is in an executable state, so when this process is selected for execution, the parent OS specified in the extended enter instruction is displayed on the delegated process.
The function will be executed.

When a special return instruction is issued upon completion of processing by a proxy process on the parent OS, and a special identifier is set in the return address information on the stack to indicate a return to the child OS, the handshake mechanism 2 is activated.

The activated handshake mechanism 2 obtains the process that requested the handshake based on the saved information of the child OS corresponding to the proxy process that issued this special return command, and adds the following to the stack of this process.
The contents of the parameter area of the stack of the substitute process are transferred, and the value ARj of the return address previously saved on the stack is set in the instruction counter area of the corresponding process. After this, parents
The corresponding proxy process on the OS is set to a waiting state, the corresponding child OS is made executable, and the VM switching mechanism 4 is activated.

When control is transferred to the corresponding child OS by the VM switching mechanism, processing is resumed from the instruction following the special enter instruction, and the execution result of the process specified by the special enter instruction is set on the stack by the parent OS. This means that the process is performed as if it were executed on a child OS.

Note that when the handshake mechanism 2 activated by the special enter command searches the handshake control table 3, if an entry with the same value as the operand part of the special enter command is not found in the key part, the normal enter command is executed. Perform the same processing as . That is, after setting the address next to the special enter instruction on the stack as the return address,
Sets the subroutine address indicated by the operand part of the special enter instruction in the instruction counter.
As a result, if the parent OS does not support handshaking of the process specified by the special enter command, the process will be performed in the child OS as a normal enter command.

One embodiment of the present invention has been described above, but as is clear from this explanation, the gist of the present invention is that when executed on a child OS, the handshake in the parent OS of the process specified in the operand part of the instruction is When executed on the parent OS, the first special machine language instruction has the same function as a branch instruction (enter instruction) to a normal subroutine. If issued upon completion, activates handshake post-processing, otherwise returns from normal subroutine (return instruction)
and a second special machine language instruction having a function equivalent to that of the second special machine language instruction issued by the child OS and specified in the operand part of the first machine language instruction. After performing the necessary processing to execute the function on the parent OS, it calls the corresponding processing routine of the parent OS, is restarted with the second special machine language instruction, and after performing the necessary post-processing, the child A handshake mechanism is provided to set the OS to a state where the specified process has finished and request the restart of the child OS, and when executed as a child OS,
For functions that can be substituted depending on the state of the parent OS, special machine language instructions for branching to the subroutine that executes this function on the OS are embedded in advance.
When an OS runs as a child OS, certain functions are
It executes on the parent OS without performing any processing on the OS, and when it is not running as a child OS, it is able to execute the functions of that OS as before.
This makes it possible to use the same program regardless of whether it is executed as a child OS.

It is clear that there are several ways to implement this as long as they do not contradict this idea.

In this embodiment, all parameters are transferred between a subroutine that performs handshake processing and the caller of this subroutine via the stack, and only simple data is transferred as parameters. . That is, it is assumed that pointers and the like are not included in the parameters. Parameters can be passed between the parent OS and the child OS by transferring the stack in the child OS and the stack of the delegated task in the parent OS, but if the parameters include pointers or if there are parameters other than the In some cases,
These can be extracted from the corresponding subroutines of the parent OS to the correct parent.
In order to be able to refer to the address on the OS, the handshake mechanism 2 handles each function, transfers the address space on the child OS to the address space on the parent OS, and converts the child OS address to the parent OS address. It may be necessary to carry out such processing.

In addition, in this embodiment, when executing a special enter instruction, a child is added to the stack of the substitute task.
Along with the return address on the OS, a flag indicating that the call is from a child OS is set, but it is not necessary to do so;
When the process in the OS ends, if it is called from the parent OS, the return destination in the parent OS can be identified and the child OS
If the call is made from a child OS, the parent
When called from the OS, any configuration may be used as long as the return address on the parent OS can be identified.

[Brief explanation of the drawing]

The figure shows an embodiment of the present invention, in which 1 is an instruction decoding and execution mechanism, 2 is a handshake mechanism, 3 is a handshake control table, and 4 is a VM.
switching mechanism; 5 is a mode flip-flop; 6 is a mode flip-flop;
Indicates the VM identification register.

Claims (1)

[Claims] 1. Determine which of a plurality of virtual machines (hereinafter referred to as VM) and a VM control program (hereinafter referred to as parent OS) that controls the virtual machines should be given control of the processor, and Or VM
VM switching means for providing a processor to a processor;
A processor state holding means that is set to VM mode when switching to VM, and set to parent OS mode when switching to parent OS, and a means for decoding and executing machine language instructions stored in main memory. In this case, if the instruction is a special enter instruction, if the processor state is in parent OS mode, it will be executed as a branch instruction to a normal subroutine, and if it is in VM mode, it will be executed as a branch instruction to a normal subroutine.
Notifies the handshake means of a processing request by handshake in the OS, and if the command is a special return command,
an instruction decoding/execution means that executes the instruction as a return instruction from a normal subroutine when the processor is not executing handshake processing, and notifies the handshake means of the end of handshake processing when handshake processing is in progress; and the special enter instruction and the special return. It is activated by a notification from the instruction decoding and execution means that processed the instruction, controls the execution by handshake in the parent OS of the process specified by the operand part of the special enter instruction, and when activated by the special return instruction, A virtual computer system comprising: a handshake means that performs handshake post-processing and puts a VM that started the handshake into an executable state. 2. The handshake means is activated by a notification from the instruction decoding and execution means that processed the special enter instruction and the special return instruction, and when activated by the special enter instruction, the handshake means is activated in response to a notification from the instruction decoding and execution means that processed the special enter instruction and the special return instruction, and when activated by the special enter instruction, the handshake means The support process prepared on the parent OS is set to a state requesting the process specified by the instruction, the VM that issued the instruction is placed in a suspended state, and the VM switching means is activated. , if started by a special return instruction,
Convert the result of the process completed on the corresponding support process on the parent OS into the format when completed on the corresponding VM, reflect this on the corresponding VM, and make the VM executable. Parents
Claim 1, wherein execution of the process specified by the operand part of the special enter instruction by handshake in the parent OS is controlled by activating the VM switching means after suspending the support process on the OS. The virtual computer system according to item 1.