JPS6118224B2 - - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION (1) Field of Application of the Invention The present invention provides a method for emulating information processing apparatuses of different systems, in which conventionally only a uniform storage protection key could be used and the emulated program The present invention relates to a means for providing various types of memory protection key values to enhance memory protection of an emulated program.

(2) Prior Art Conventionally, emulation techniques have been used to cause a program that was running on an information processing device with a different system, for example a different instruction set, to run on an information processing device with a new system. The emulation technique allows previously developed programs to be executed for a new information processing device without having to be converted, thereby simplifying the migration procedure. however,
Conventional emulation techniques have had problems in memory protection operations between emulated programs. This will be explained below with reference to the figures.

FIG. 1 is a schematic diagram of an information processing device including an emulation mechanism. 1 is an instruction decoding unit (hereinafter referred to as
2 is an instruction execution unit (hereinafter abbreviated as EU), 3 is a storage control unit (hereinafter abbreviated as SCU), 4 is a main memory (hereinafter abbreviated as MS), and 5 is a diagnostic control unit (hereinafter abbreviated as SVU). ).
The emulate mechanism is incorporated into the IU and EU as part of the microprogram and part of the circuit.

Figure 2 shows how to use the emulate mechanism.
FIG. 2 is a schematic diagram showing how programs are arranged within an MS. Each number corresponds to an address on the MS. Address ranges 1 and 2 are for the control program that governs the entire system, and address ranges 2 and 3 are for the input/output requests of the emulated program. There is an emulator control program that converts the control program into a request format, simulates some instructions, and issues instructions for operating the emulation mechanism. In address ranges 3 and 4, there is an emulated control program written using old instructions, which controls the emulated user program. Address ranges 4 to 5 and address ranges 5 to 6 contain emulated user programs, which are also written using old-style instructions. Address ranges 6 to 7 contain user programs written with new style instructions. The number of user programs between address ranges 4 to 6 and 6 to 7 is
Only the number allowed by the control program exists at the same time. Furthermore, whether the address is a real address or a virtual address does not affect the present invention.

As for the control program, address ranges 2 to 6 and address ranges 6 to 7 are interpreted as user programs written using the new method and executed. Therefore, from address range 2 to 6,
Each of address ranges 6 to 7 forms a job, and both run unprivileged. In addition, normally each job is given a protection key value and a memory protection key value by the control program.
This prevents programs executed in each job from accidentally destroying information in other job areas. However, the control program can operate any part of the MS.

Since address ranges 2 to 6 are configured as one job, the protection key values are the same.
Therefore, there is a risk that emulated user programs may accidentally destroy information with each other or destroy the contents of the emulated control program. It is impossible for the emulator control program or the emulated program, that is, the emulated control program or the emulated user program, to accidentally destroy information of programs in other address ranges because the values of the memory protection keys are different.

In this way, since only a uniform memory protection key can be held in the address range 2 to 6, it has not been possible in the past to prevent information destruction due to errors between emulated programs.

address range 2 to 3, 3 to 4, 4 to 5,
It is also possible to assign independent memory protection keys to each of 5 and 6 as jobs, but in this case, when the emulated program or the emulator control program manipulates the information of the emulated program, The value must be the same as the memory protection key held by the other program, and the overhead required to request the control program to perform this procedure and the overhead required to exchange information between different jobs are required, making it difficult to emulate There is a noticeable drop in performance when running the program.

(3) Purpose of the Invention The present invention provides a means for preventing information destruction due to errors between emulated programs when programs are executed using an emulation technique, and achieves the means with low overhead. The purpose is to

(4) Examples Hereinafter, the present invention will be explained in detail with reference to examples.

Usually, an emulate mechanism has an instruction for entering the emulate state and an instruction for translating the address of a channel command word (hereinafter abbreviated as CCW) for performing input/output. When the information processing device enters the emulate state, it treats address 3 in FIG. 2 as if it were address 0 and starts executing the program. Hereinafter, such a state will be referred to as a local execution state, an address converted so that address 3 in Figure 2 becomes address 0 will be referred to as a local address, and a normal address with address 1 in Figure 2 as address 0 will be referred to as a program address. call.

To enter the local execution state, a local execution instruction is issued. The locally executed instruction is 1 in FIG. 3, and the operand address of that instruction indicates a parameter group 2 called a local execution list. When this command is executed, the information processing device enters the local execution state and imports the necessary information indicated in the local execution list into the information processing device. The local execution list contains various types of information. 3 is the local address that is the first instruction address to which control is transferred when the local execution state is entered, 4 is the program address indicating local address 0, and 5 is the local address. The maximum value of local addresses corresponding to 6 in FIG. 2 is stored as a local address. If the local address indicates outside the local address range indicated by 4 and 5, a program interrupt indicating an address exception occurs. As a result, the emulated program cannot refer to or store information in a range other than 3 to 6 in FIG. 2.

The local execution state is stopped when some kind of interrupt occurs inside the information processing device. Information regarding the local execution state at this time is stored in the local execution list, and if it is a specific interrupt, the address of the next instruction to be executed is a program address and is stored in the local execution list.

Memory protection operations related to the present invention are typically performed as follows. The information processing device has a program status word (PSW) that indicates the execution status of the program.
), and within this is a field that holds the protection key assigned to each program. In addition, a memory protection key is stored in the SCU for each partition in the main memory, and the protection key in the PSW during program execution and the main memory address required by the program being executed are located in the main memory. between the device partition storage key value and
If a certain rule does not hold, a program interrupt of a memory protection exception occurs and execution of the instruction is prevented. To change the protection key, use the load PSW instruction, which is an instruction that changes the program state word.
There is a set storage key command (hereinafter abbreviated as SSK command) to change the memory protection key, and an insert storage key command (hereinafter abbreviated as IS command) to read the memory protection key. These three instructions are privileged instructions and cannot be executed unless the program status word indicates a privileged status.

FIG. 4 shows an example of the law between storage protection keys and protection keys. Here, if the value of the protection key is other than 0 and the value of the protection key differs from the value of the memory protection key, a program interrupt occurs and a memory protection operation is performed. Normally, the control program is executed in a privileged state with a protection key value of 0. However, the emulated control program executes in an unprivileged state and with a protection key having a non-zero value despite the control program as described above. All privileged instructions issued by the emulated control program generate program interrupts of privileged instruction exceptions, which are simulated by the emulator control program. Since the emulator control program is also not in a privileged state, privileged instructions cannot be issued.

During operation of the emulator, since only the same protection key and memory protection key are assigned to the emulated programs, the memory protection operation between the emulated programs is not performed.

In the present invention, a memory protection key storage device is added,
The protection key and memory protection key operation instructions during local execution state have been slightly changed, and even during local execution state,
It is designed to perform memory protection operations.

Due to recent significant advances in semiconductor technology, storage protection key storage devices have become able to realize large amounts of storage devices in a very small size and at low cost. Sufficient quantity can be supplied.

The present invention will be explained with reference to FIG. Reference numeral 1 denotes an additional storage protection key storage device, which stores the storage protection key value specified by the SSK instruction executed in the local execution state. The storage key value is then sent over line 2. Also, which part of the storage protection key storage device is to be changed is indicated by the SSK command, and its local address is sent through line 3. The memory protection key value is given to each storage area unit of the main memory 4 of each emulated program, and different memory protection key values are assigned to the storage areas of different emulated programs. Loads issued during local execution instructions
In the PSW instruction, the value of the protection key in the PSW is set to line 6.
The virtual protection key register 7 is set through the virtual protection key register 7. The value of the protection key set in the register 7 is set to match the additional storage protection key assigned to the storage area in the main memory 4 of one emulated program that is being executed. Also, when a locally executed instruction is executed, information indicating the local execution status is set in latch 14 through line 13. When latch 14 is on, it indicates a local execution state. When an interrupt occurs in the information processing device, a latch 14 is sent through line 13.
is reset. Through line 18, latch 14
The value of can be read. In the local execution state, when referencing a storage device, the current local address is sent through line 3, and the corresponding storage key value in the additional storage key storage device is read, and it is transferred to line 4. It is input to the comparator circuit 5 through line 19. The virtual protection key value contained in the virtual protection key register 7 during the local execution state is also input to the comparator circuit 5 via line 8. This comparison circuit detects whether the additional storage protection key and the virtual protection key match or not, and sends a mismatch signal to line 12 if they do not match. The virtual protection key is also sent to circuit 10 via line 9. The circuit 10 is a circuit that detects whether the virtual protection key value is 0 or not, and sends out a 0 detection signal to the line 11 when the virtual protection key value is 0. When latch 14 is on, it is sending a local run status signal on line 18. Line 11, 12, 1
The signals sent through 8 each enter a circuit 16.

Circuit 16 is a memory protection exception detection circuit. Here, the fourth
Memory protection exception detection is performed according to the rules shown in the figure.
That is, when the virtual protection key 0 detection signal sent through line 11 is off, the key mismatch signal sent through line 12 is on, line 21 is on, and line 18 indicates the local state. line 17
Then, a storage protection exception signal is sent. When this is turned on, a specific microprogram address is created and a program interrupt handling microprogram for memory protection exceptions is executed.

For an ISK instruction in the local execution state, the local address is sent over line 3 and the corresponding virtual memory protection key is read out over line 4 and line 20.

In local execution state, load PSW instruction,
The SSK command and ISK command are executed according to the flowchart shown in FIG.

In case of load PSW instruction, execute as follows. When the load PSW instruction is decoded, a specific microprogram address is generated and enters entry 61 in FIG. The determiner 62 determines whether or not it is in a local execution state. This is possible if the value of line 18 in FIG. 5 can be referenced by the microprogram. In the local execution state, go to box 63 and select box 3.
Now, only the protection key portion of the PSW indicated by the operand of the load PSW instruction is set in the virtual protection key register 7 in FIG. After that, the process goes to the determiner 64. If it is not in the local execution state, the process immediately goes to determiner 64. The determiner 64 determines whether the information processing device is in a privileged state, and if it is in a non-privileged state, the information processing device goes to an exit 65 to go to the program interrupt processing microprogram. Thereafter, the program interrupt operation is performed by the program interrupt processing microprogram.
Load PSW normally issued in local execution state
Since the instruction is issued in an unprivileged state, exit 65
Go to. A load PSW instruction that is executed in a privileged state will perform the operations required by the instruction, i.e., in box 66.
Load information into PSW and exit 67 for normal instructions
Go to. Upon exit 67, the next instruction is decoded and executed.

The SSK and ISK instructions are executed as follows. First, when the SSK or ISK instruction is decoded, the address of a specific microprogram is generated,
It comes in entry 71 in FIG. Next, the microprogram uses a determiner 72 to determine whether it is in a local execution state. In the case of a local execution state, go to box 73, and in the case of an SSK instruction, send the local address at which the storage protection key should be changed and the value of the storage protection key to be changed through lines 3 and 2 in Figure 5, respectively. , additional memory protection key storage device 1
Write in. In the case of the ISK instruction, the local address from which the memory protection key is to be read is sent through line 3 in Figure 5, the required virtual memory protection key value is read through line 4 and line 20, and the value is read from a general-purpose register or main memory. Write it on the device. After that, the process goes to the determiner 74. If it is not in the local execution state, the process immediately goes to the determiner 74. The determiner 74 determines whether the state in which this instruction is executed is a privileged state or not. If you are in a privileged state, box 7
6, normal ISK or SSK instruction processing is performed. After that, it goes to exit 77 and proceeds to execute the next command. Exit 7 if not in privileged state
At step 5, the program branches to a program interrupt processing microprogram routine in order to cause a program interrupt due to a privileged instruction exception.

Create the load PSW instruction, ISK, and SSK instructions in a microprogram as explained above,
As long as the emulated program is run in the local execution state and unprivileged state, the load PSW command issued there will cause the virtual protection key to be stored in the virtual protection key register 7 in FIG.
The SSK instruction writes a virtual storage key to the corresponding local address location in the additional storage key storage. Its value can also be read by the ISK instruction. When an instruction is executed in the local execution state, the local address used at that time is sent to the additional memory protection key storage device through line 3 in Figure 4, and the read virtual memory protection key is compared with the virtual protection key. If the MS access does not follow certain rules and the information is stored, a program interrupt with a memory protection exception will occur. If the execution state is the local execution state, the program interrupt handling microprogram resets it, stores the program address of the last executed instruction in the local execution list, and at the same time interrupts the execution state to indicate that a memory protection exception has occurred. It also stores code, obtains from the local execution list the program address of the instruction to which control should be transferred when a specific program interrupt occurs, and branches there. Usually, it contains the start address of the program interrupt handling program within the emulator control program.

The program interrupt processing program detects the occurrence of a storage protection exception and stops the corresponding emulated program. When a program interruption due to a memory protection exception occurs, the information storage operation is inhibited, so that information is not destroyed.

The emulated program can be brought into a locally executed state by executing a local execution command when transferring from the emulator control program to the emulated program. Also the second
As is clear from the figure, the emulated program and the emulator control program constitute one job, and from the control program's perspective, they appear to be the same as other user programs, and are executed in a non-privileged state.

In this way, the emulated program operates in the locally executed state and in the privileged state because
This is a common practice.

The emulator control program does not receive the storage protection described in this invention. This is because you are outside the local address range. However, if the emulated program attempts to access outside the local address range, an address exception program interrupt will occur due to monitoring by the emulation mechanism, so the emulator control program will be destroyed by the emulated program. There's no fear. Therefore, it is not necessary to apply the present invention to the emulator control program.

Apart from the memory protection described in the present invention, memory protection operations for the entire main storage device from address range 1 to address range 7 in FIG. 2 are always performed, and the present invention has no adverse effect on them. There is no need to worry about it.

What kind of memory protection key and protection key are given to each emulated program is controlled by the emulated control program, and the virtual protection key, virtual memory You can freely change the value of the protection key.

Load in local execution state and unprivileged state
When a PSW instruction, SSK instruction, or ISK instruction is executed, a program interrupt occurs, and if the address of a specific routine in the emulator control program is written in the local execution list as the address to which control is transferred at that time, it is necessary for the present invention. After the appropriate information is set, the emulator control program can perform the necessary program operations. Particularly in the case of the ISK instruction, if the microprogram stores the virtual memory protection key value read through line 20 in FIG.
If the problem occurs due to an ISK instruction, the emulator control program saves the contents of the general-purpose register, and when branching to the emulated program later, the emulated program only needs to recover the general-purpose register. Therefore, the ISK instruction is the same as if it were executed.

If you want to add other functions to the memory protection function, such as read protection, you can easily perform local execution by increasing the number of bits of the additional memory protection key storage device shown in Figure 5 and adding a circuit that implements the rules regarding read protection operation. Extensions of the present invention can be made with respect to extended storage protection operations in states.

After an interrupt occurs, the local execution state is no longer present, so the load PSW instruction, SSK, and ISK instructions are executed as usual.

Even if the protection key and storage protection key operation command are different from those described here, the present invention can be carried out by using the same method as the flowchart of FIG.

(5) Summary As described above, according to the present invention, memory protection can be performed between emulated programs in the local execution state. The present invention can be executed without any interference with normally performed memory protection operations, and can be implemented as small-sized hardware as semiconductor technology advances.

[Brief explanation of the drawing]

FIG. 1 is a diagram showing the internal configuration of an information processing device including an emulation mechanism, FIG. 2 is a layout diagram of the main storage device when an emulated program is executed, and FIG. 3 is a diagram showing the local execution A diagram showing the layout of a local execution state, which is an instruction for moving to a state, and a local execution list used by that instruction. FIG. 4 is a diagram showing the rules for performing a memory protection operation. FIG. FIG. 6 is a flowchart showing the processing of ISK or SSK instructions modified by the present invention; FIG. 7 is a load PSW modified by the present invention. FIG. 3 is a diagram showing instruction processing.

Claims (1)

[Scope of Claims] 1. A memory that stores a control program, an emulator control program, and a plurality of emulated programs, and provides a common protection key to the emulator control program and the plurality of emulated programs; A storage area of the emulator control program and the plurality of emulated programs in the memory is given storage protection that matches the protection key, and the emulator control program executes the emulated programs under the control of the control program. An information processing device that executes a program includes a memory protection key storage device for storing an additional memory protection key allocated to each storage area in the memory of each of the plurality of emulated programs; a register for storing a protection key for the emulator program being executed as a virtual protection key, which is determined for each emulated program to be equal to the additional storage key for the emulator program; A latch stores information indicating whether or not one of the programs to be emulated is being executed, and an additional memory protection key read from the memory protection key storage device based on a local address generated during emulation operation is included. The second to compare with the virtual protection key
When the circuit and the comparison result do not match, the latch indicates that the emulated program is being executed, and the emulated control program instructs to store information in the memory, the and a circuit that suppresses the storage operation of the information. An information processing device that enables memory protection of the emulated program.