Data processing: software development – installation – and managem – Software program development tool – Translation of code
Reexamination Certificate
2000-07-26
2004-04-20
Ingberg, Todd (Department: 2124)
Data processing: software development, installation, and managem
Software program development tool
Translation of code
Reexamination Certificate
active
06725451
ABSTRACT:
BACKGROUND OF THE INVENTION
The invention relates to a method for converting a system call for an origin operating system into a system call for a destination operating system.
The invention can be employed in particular when an application program that has been created for an origin system (processor and operating system) is supposed to run on a different destination system. In particular, the invention is provided for cases when the origin and destination operating systems are in fact related, but are nevertheless somewhat different from one another. For example, the two operating systems can be a matter of different UNIX variants or of major ports of an operating system to different hardware. Thus, the following deviations of the hardware architecture can affect the interface between the application program and the operating system:
different address ranges and/or address space topologies (e.g. transition from a 32-bit system to a 64-bit system);
different sequence of bytes of binary numerical values in the memory (e.g. transition from a little endian system to a big endian system), and
different coding of characters (e.g. transition from an ASCII system to an EBCDIC system).
It is a known procedure when transferring to a different processor architecture to port the original operating system to the destination processor as well. Expansions of the operating system that may be provided are then performed in such a way that the previous functionality is left unchanged (downward compatibility). Known methods such as emulation or static or dynamic object code transformation serve for the execution of the application programs. The system calls contained in the application programs need not be taken into account separately, since they are valid on the ported operating system.
However, it is expensive to port the operating system to the destination computer as required by this method. To obtain downward compatibility, it is often necessary to make technical compromises which degrade the performance capability of the new operating system.
U.S. Pat. No. 5,313,614 teaches to port both an application program and an original operating system to the new computer, which comprises an independent operating system on its part. In this case, the system calls of the application program can be maintained unchanged. However, due to the necessary porting, this method is relatively expensive.
SUMMARY OF THE INVENTION
Accordingly, it is an object of the invention to avoid the cited problems and to set forth a method for converting a system call which does not require porting of the original operating system and which nevertheless makes it possible to have an application program run on the destination system without any specific adjusting or retranslation. This is particularly significant when the application program is present only as object code.
This object is achieved by a method of the invention for converting a system call for an origin operating system into a system call for a destination operating system wherein an emulation routine is called. With the emulation routine, a reference structure is converted which comprises at least one referenced element by converting at least a reference value. With the emulation routine, the system call is performed for the destination operating system. The conversion of the reference structure can relate to a parameter for the system call as well as to a result value of the system call. The term “system call” here is intended to subsume the entire process that is associated with the call of an operating system service (including the return of the result value).
The invention is based on the fundamental idea of system calls (supervisor calls) of the application program to the origin operating system using specific emulation routines and converting them into calls to the destination operating system. What is essential for the invention is to lay out suitable methods for converting reference structures. In this context, reference structures are structures that not only contain the actual data, but also comprise a reference value with the aid of which it is possible to access referenced elements (data, functions, private areas of the operating system, . . . ). In many cases, in procedure or system calls only the reference value is delivered, for instance a pointer or an index or a designator. The term “structure” as used here should be understood in the broadest sense as any arrangement of data and/or references and should not be limited to the data type of a “structure” in the programing language C.
The invention opens up the possibility of executing application programs on new and advanced systems. When the machine languages of the original and new systems agree (binary code compatibility), the application program can run on the destination system unchanged or with minimal modifications. Otherwise, a suitable conversion must be provided by known methods. For example, an emulator for the machine language of the application program can be provided, or techniques of static or dynamic object code transformation can be employed. The invention can be utilized in all these techniques to provide a conversion of system calls.
Besides being applied in the migration of application programs, the invention can also be employed when a client/server architecture is to be set up from client and server components that are not matched with one another. In this case, the method of the invention is executed by an adapter which is inserted between client and server or which surrounds the server in the sense of an intermediate layer (wrapping). Furthermore, the method of the invention can also be executed by adapters that have been generated automatically from an IDL interface description (IDL: Interface Definition Language). In general, the invention can be used when system calls with reference structures can arise. These can be a matter of calls of a (local) application program or of non-local calls (remote procedure call or remote system call).
In preferred embodiments of the invention, the emulation routines execute at least primarily conversion functions (as opposed to operating system functions). Preferably, the proportion of conversion functions is over 70% or over 90%, and the proportion of other functions is only small. The essential work is thus performed by the destination operating system. The emulation routines can then be kept relatively compact and are much less expensive to develop than the porting of an operating system would be.
In preferred embodiments, if necessary not only the reference value but also the at least one referenced element is at least partially converted. The referenced element can also be a matter of an element that cannot be interpreted further, however. For example, it can be an element of an abstract data type. In this case, a conversion table is preferably provided in order to assign reference values to one another in accordance with the conventions of the origin and destination operating systems. The conversion table can be implemented by arbitrary means which provide this assigning functionality.
In other preferred embodiments, the referenced element can be a function. The emulation routine then preferably replaces the original reference value with a new reference value that references an adapter function. The adapter function can be generic or can be specifically generated in the conversion dependent on the type or other characteristics of the origin function. A table can be used here as well.
In further embodiments, the referenced element is a system file and/or a tuple and/or a concatenated data structure and/or a date and/or a time indication and/or a context and/or an array and/or a character string. In these and other cases, the referenced element can have a significance that can be interpreted by the emulation routine. The conversion occurs in such a way that this significance is maintained to the greatest extent possible.
REFERENCES:
patent: 5313614 (1994-05-01), Goettelmann et al.
patent: 5339422 (1994-08-01), Brender et al.
pa
Schuetz Wolfgang
Stadel Manfred
Ingberg Todd
Schiff & Hardin LLP
Siemens Aktiengesellschaft
LandOfFree
Method for converting a system call does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Method for converting a system call, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method for converting a system call will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3272607