Classifications

• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F9/00—Arrangements for program control, e.g. control units
  • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
  • G06F9/44—Arrangements for executing specific programs
  • G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F9/00—Arrangements for program control, e.g. control units
  • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
  • G06F9/44—Arrangements for executing specific programs
  • G06F9/445—Program loading or initiating
  • G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F9/00—Arrangements for program control, e.g. control units
  • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
  • G06F9/46—Multiprogramming arrangements
  • G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
  • G06F9/5061—Partitioning or combining of resources
  • G06F9/5077—Logical partitioning of resources; Management or configuration of virtualized resources
• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F9/00—Arrangements for program control, e.g. control units
  • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
  • G06F9/46—Multiprogramming arrangements
  • G06F9/54—Interprogram communication
  • G06F9/545—Interprogram communication where tasks reside in different layers, e.g. user- and kernel-space
• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F2209/00—Indexing scheme relating to G06F9/00
  • G06F2209/54—Indexing scheme relating to G06F9/54
  • G06F2209/542—Intercept

Definitions

• the present invention relates to a method for virtualizing a hardware resource associated with a computer system by means of a piece of executable code adapted to be injected into a process belonging to an application running on an operating system comprising at least one interface of application programming (API) and running on the computer system,
• API application programming
• the invention also relates to a system and executable code part suitable for carrying out this procedure.
• virtualization can be defined as the creation by software of a version virtual of a technological resource, such as a hardware platform, an operating system, a data storage device or other network resources, so that this resource can be divided into one or more runtime environments. It is important to note that this may also be the case in which this software is assisted by virtualization hardware technology, such as Intel-VT or AMD-V (see, for example, Wikipedia in Spanish - ht ⁇ p: //es.wik ⁇ pedia,org / wikiA ir ⁇ ualiza
• One of the most commonly virtualized technological resources is a computer system (for example, a personal computer or a server), which allows this computer system to run multiple instances of different operating systems concurrently. In this way, the computer system is capable of running different applications that require different operating systems.
• a type of virtualization that allows to emulate the hardware resources of the computer system is also known. For this, it is necessary to install virtualization software in the computer system that aims to make the hardware resources of the computer system accessible to all installed operating systems. In addition, this virtualization software also aims to coordinate access to virtualized hardware resources by the different operating systems installed in the computer system.
• the virtualization of hardware resources of a computer system (although it is also applicable to any other type of virtualization), although it has some advantages (for example, as mentioned above, allows the execution of several operating systems concurrently on the same computer system), also has a significant number of drawbacks.
• this type of virtualization can lead to a decrease in the performance of the computer system, as a result of the overhead of executing virtualization software on the computer system.
• the execution of applications may be affected, which may run slower than in non-virtual systems.
• This objective is achieved in accordance with claim 1 by providing a method for virtuaising a hardware resource associated with a computer system by an executable piece of code adapted to be injected into a process belonging to an application running on a system.
• operating system comprising at least one application programming interface (API) and running on the computer system, the procedure comprising:
• data flow management refers to the transmission and / or control of the data flow, so that the services that the process calls are related to the management of the data flow.
• the injected piece of code intercepts the call, it is the piece of code that controls this management, for example sending the contents of a virtual buffer.
• interception means the fact that the process call to the API service implies a redirection to a service included in the piece of code, so that it is the piece of code itself that receives the process call to Run this service corresponding to the API service (that is, the process call does not reach the API service).
• the code piece manages to take control of the data flow between the process and the hardware resource when the process makes a request for access to it, to the operating system, since the code piece acts above the system operational
• the piece of code may have redirected one or more services from one or more APIs related to the data flow management that occurs between the process and the hardware resource towards corresponding services included in the piece of code, so that, ta! As mentioned above, the call from! The process is no longer performed on an API service but on the corresponding service included in the code piece.
• the piece of code can manage the flow of data that occurs between e! process and the hardware resource and thus virtualize the hardware resource, since the services included in the piece of code are adapted for it.
• a service refers to at least one service, at least one API, at least one call and / or a! less a hardware resource, respectively.
• redirect two services from the same API to two services included in the piece of code that is, at least two calls made by the process
• redirect a service from a first API to a first service included in the code piece and a second AP service! to a second service included in the code piece that is, at least two calls made by the process
• the same piece of code is able to virtualize one or more hardware resources, such as a video card, an audio card, a hard disk, a keyboard or a mouse , depending on the needs of the application during its execution.
• the process belonging to the application can be started in a state of suspension, and during this state of suspension the executable code piece is injected into the process. Therefore, the process according to the invention should contemplate the possibility of restarting the process if it has been started in a suspended state. In this way, the correct functioning of the code piece is ensured.
• the API service can be a function
• the step of redirecting an API service related to the management of the data flow that occurs between the process and the hardware resource towards a corresponding service included in the code piece may include:
• the initial memory address in which the API function to be redirected is stored by the initial memory address in which it is stored. stores the corresponding function included in the code piece.
• the piece of code can perform the redirection of one or more functions of one or more APs! towards corresponding functions included in the piece of code, so that it can intercept the calls to these functions by the process and thus manage the flow of data that occurs between the process and the hardware resource (or hardware resources if the application requires virtualizing more than one), which allows its virtualization.
• the step of redirecting an API service related to the management of the data flow that occurs between the process and the hardware resource to a corresponding service included in the piece of code may also comprise storing the address in a first variable of initial memory in which the API function to be redirected is stored, so that this function of the AP! (that is, the original function) may be called from the executable code piece itself, if necessary at some time during the execution of the application.
• the API service can be a method of an object, and the stage of redirecting an API service related to the management of the data flow that occurs between the process and the hardware resource towards a corresponding service included in the code piece can
• the step of redirecting an API service related to the management of the data flow that occurs between the process and the hardware resource to a corresponding service included in the piece of code may also comprise storing the address in a second variable of initial memory in which the method of the object to be redirected is stored, so that if at any time during the execution of the application it requires, this method (that is, the original method) may be called from the code piece itself.
• the step of intercepting a process call belonging to the application to an API service related to the management of the data flow that occurs between the process and the hardware resource may comprise receiving a process call to the service included in the piece of code corresponding to the API service related to the management of the data flow that occurs between the process and the hardware resource.
• the services included in the piece of code to which the process makes calls may be different.
• the step of managing the data flow that occurs between the process and the hardware resource may comprise:
• the generation of this virtualized hardware resource may include:
• Virtualized buffer generation is due to the fact that much of the hardware resources of a computer system comprise or have associated with the less a buffer (more specifically, each hardware resource can have at least one memory area reserved) in which the hardware resource can store data so that they can join the process (normally, the process makes a request to obtain it) or in which the process can store data so that they reach the resource (normally, the resource is able to take them), that is, the buffer serves as a tool for exchanging data between the process and the resource.
• the memory area reserved for the exchange of data between the process and the resource is a different one that is not under the control of the operating system and / or of the controllers associated with real resources, but be under the control of the piece of code.
• each running application that has injected a piece of code according to the invention can have at least one buffer of its own and not one shared with the rest of the applications, typical of the resource of hardware.
• the thread of execution its generation may be necessary mainly to simulate the behavior of the hardware resource of the computer system and, among other things, to properly manage the data generated by the piece of code, through the figure of the virtualized hardware resource, as well as of the data generated by the process, which are exchanged between them through the virtualized buffer, as discussed above. It is important to emphasize that the execution thread can be represented, for example, by at least one function included in the code piece, so that the execution of the thread really implies the execution of this function.
• the step of managing the data flow that occurs between the process and the hardware resource may also comprise storing in the virtualized buffer the data sent by the process a! hardware resource.
• the piece of code can manage the data flow that occurs between the process and the hardware resource, since the data is stored in the virtualized buffer, which is under the control of the piece of code.
• this data generated by the process was destined to the hardware resource of the computer system (that is, the actual hardware resource), but the interception of the process calls to certain API services by the code piece allows this data to be under control of it.
• the stage of managing the data flow that occurs between the process and the hardware resource may comprise:
• the piece of code In the event that the virtualized hardware resource has an execution thread that simulates the behavior of the computer system hardware resource, the piece of code must stop the execution thread for a predetermined time (usually of the order of milliseconds), to that afterwards the thread of execution obtains the data that the process has stored in the virtualized buffer. Once this data is obtained, the thread of execution must process it just as the hardware resource of the computer system would.
• the processing of this data may involve converting it, for example, to the mp3 format (that is, according to the MPEG-audio standard, layer III), so that then be interpretable.
• the step of managing the data flow that occurs between the process and the hardware resource may comprise sending the processed data to a first computer system. remote. Since the data, after processing, is still controlled by the piece of code through the virtualized hardware resource, this data can be sent to a remote computer system (different from the computer system comprising the actual hardware resource) that It is the one that really makes use of them, although they can also be sent to the computer system itself on which the application is running or to any other local computer system.
• the piece of code since the piece of code has control of the audio data, it is able to make this audio data, instead of being heard through the actual audio card associated with the computer system, be heard through the real audio card of the remote computer system (for example, a terminal or mobile device, such as a smartphone or tablet).
• the data once processed by the thread of execution (remember that it is not more than at least one function included in the thread of execution), if they are interpretable by the audio card of the computer system, there should be no problem for that are interpretable by the audio card of any other computer system, since they have already been adapted for it.
• the procedure may comprise managing the data flow that occurs from the virtualized hardware resource to the process belonging to the application.
• This data flow management in the specified direction may include:
• the piece of code can at any time receive data from a second remote computer system (although normally the first and second remote computer systems are going to be the same remote computer system), which must be processed and stored in the previously created virtualized buffer , so that they are accessible by the process.
• the piece of code (more specifically the execution thread that simulates the behavior of the hardware resource) can receive keyboard data from the remote computer system (for example a tablet), such as data generated from a keyboard on which the user acts through the touch screen of the tablet. This data must be processed by the thread of execution and stored in the buffer.
• the step of intercepting a process call belonging to the application to an API service related to the management of the data flow that occurs between the process and the hardware resource may comprise:
• the step of intercepting a process call to an API service related to the management of the data flow that occurs from the hardware resource to the process may comprise receiving a process call to the service comprised in the piece of code corresponding to the API service related to the management of the data flow that occurs from the hardware resource to the process.
• the procedure may also include managing the data flow that occurs from the hardware resource of the computer system (ie, the actual hardware resource) to the process, with the aim of ensuring that it is the virtualized resource that continues to control correctly the application, and not the real resource,
• the stage of managing the data flow that occurs between the process and the hardware resource may include:
• the invention provides an executable piece of code that can comprise instructions for executing a procedure to virtualize a hardware resource associated with a computer system such as that described above, this piece of code being adapted to be injected into a process belonging to an application, when this application is executed on an operating system that comprises at least one application programming interface (API) and which is executed on the computer system.
• This piece of executable code may be stored in physical storage media, such as recording media, computer memory, or read-only memory, or it may be carried by a carrier wave, such as electrical or optical.
• a system for virtualizing a hardware resource associated with a computer system on which an operating system is executed comprising at least one application programming interface and on which an application is executed which It comprises a process, being able to understand the system:
• the invention also provides a computer system on which an operating system is executed that can comprise at least one application programming interface and on which at least one application is executed, the computer system being able to comprise a memory and at least one processor, being able to store this memory instructions executable by the processor corresponding to a piece of executable code such as the one described above injected into a process belonging to the application, being able to comprise the instructions functionalities for:
• At least two applications on the operating system can be executed on the described computer system, and the memory can store instructions executable by the processor corresponding to a piece of code for each running application.
• the invention can also provide an executable application on an operating system running on a computer system, this application may comprise a piece of executable code such as that described above.
• the hardware resource may be an audio card
• the step of intercepting a process call belonging to the application to a service of an application programming interface (API) related to flow management of data that occurs between the process and the hardware resource may comprise intercepting a process call to a service of an AP!
• API application programming interface
• the step of managing the flow of data that occurs between the process and the hardware resource by the piece of code may comprise managing the flow of audio data that is produced from the process to the audio card. More specifically, the step of managing the flow of audio data that occurs from the process to the audio card may comprise verifying whether a virtualized audio card that corresponds to the audio card of the computer system has been generated; and in case of negative verification result, generate the virtualized audio card.
• the described step of generating the virtualized audio card may comprise generating at least one buffer that virtualizes the buffer associated with the audio card of the computer system, and generating an execution thread that emulates the behavior of the audio card of the computer system.
• the step of managing the audio data stream that occurs between the process and the audio card may comprise storing the audio data sent by the process to the audio card in the virtualized buffer.
• the step of managing the flow of audio data that occurs between the process and the audio card may comprise stopping for a predetermined time the generated execution thread that emulates the behavior of the audio card of the computer system; obtain the audio data stored in the virtualized buffer, previously sent by the process to the audio card, by the thread of execution; and process the audio data obtained by the thread of execution.
• This stage of processing by the thread of execution of the audio data obtained from the virtualized buffer may comprise mixing the data obtained from at least one virtualized buffer, and converting the mixed audio data to an interpretable format (for example, to a format mp3).
• the hardware resource may be a video card
• API application programming interface
• the stage of managing the flow of video data that occurs from the process to the video card may comprise verifying whether a virtualized video card has been generated that corresponds to the video card of the computer system; and in case of negative verification result, generate the virtualized video card.
• the described step of generating the virtualized video card may comprise generating a buffer that virtualizes the buffer associated with the video card of the computer system, and generating an execution thread that emulates the behavior of the video card of the computer system.
• this buffer is called Drawing Context (in English, Drawing Coniext (DC)), and can be defined as a memory area in which the video card stores the resulting graphics by frame and is always associated with a window.
• the step of managing the flow of video data that occurs between the process and the video card can comprise stopping for a predetermined time the generated execution thread that emulates the behavior of the video card of the computer system; obtain the video data (frames) stored in the virtualized DC, previously generated by the video card, by the thread of execution; and process the video data obtained by the thread of execution.
• This stage of processing by the thread of execution of the video data obtained from the virtualized buffer may comprise encoding the frame by means of a codec, for example, H.264.
• the hardware resource may be a data input device, such as a keyboard or a mouse.
• a data input device such as a keyboard or a mouse.
• the piece of code should intercept the process call to the function that queries (subtracts the message from the queue to read it) and treats (performs a certain action) the messages that may be in the message queue that the system operational has associated with the application.
• the function of the piece of code that treats the messages in the message queue can delete messages that the application does not want to treat (that is, it is intended to ignore them) or it may also call the original function for the application to treat the message (that is, it is intended to act on that message).
• the step of intercepting a process call belonging to the application to a service of an application programming interface (API) related to the management of the data flow that occurs between the process and the hardware resource may comprise intercepting a process call to an API service related to the management of the data flow that occurs from the process input device ; and the step of managing the data flow that occurs between the process and the hardware resource by the piece of code may comprise managing the data flow that is produced from the process input device. More specifically, the step of managing the data flow that occurs from the input device to the process may comprise verifying whether a virtualized input device that corresponds to the input device of the computer system has been generated; and in case of negative verification result, generate the virtualized input device.
• API application programming interface
• the described step of generating the virtualized input device may comprise generating a buffer that virtualizes the buffer associated with the input device of the computer system, and generating an execution thread that emulates the behavior of the input device of the computer system.
• the step of managing the data flow that occurs from the virtualized input device to the process belonging to the application may comprise receiving data from a remote computer system, this data being generated by an input device (such as a keyboard , a mouse, whether or not through a touch screen) of the remote computer system; process the received data; and store the processed data in the virtualized buffer.
• the step of managing the data flow that occurs from the virtualized hardware device to the process belonging to the application may also comprise recovering the data stored in the virtualized buffer; and send the recovered data to the process.
• the hardware resource may be a storage unit, such as a hard disk;
• the step of intercepting a process call belonging to the application to a service of an application programming interface (API) related to the management of the data flow that occurs between the process and the hardware resource may comprise intercepting a call from the process to an API service related to the management of the data flow that occurs from the process to the storage unit;
• the step of managing the data flow that occurs between the process and the hardware resource by the piece of code may comprise managing the data flow that is produced from the process to the storage unit.
• the step of managing the flow of data that occurs from the process to the hard disk may comprise changing the directory path in which the data from the process is stored.
• the piece of code for a given application, must be able to virtualize one of the hardware resources described, or a plurality of them. For this reason, the piece of code must be adapted and must contain the instructions necessary to achieve virtualization of one or more of these devices.
• Figure 1 is a block diagram showing the layers of execution of an application on a computer system, according to the state of the art
• Figure 2 is a block diagram representing the layers of execution of an application on a computer system that also incorporates a layer that represents a piece of code injected into a process belonging to the application, this piece of code intended to virtuaise the less a hardware resource associated with the computer system on which the application is executed, according to the invention.
• Figure 1 shows a diagram representing the layers of execution of an application (for example, a game) on a computer system (for example, a personal computer, a server, etc.), according to the state of the art.
• an application for example, a game
• a computer system for example, a personal computer, a server, etc.
• the lowest level layer 10 represents the hardware resources of the computer system such as the microprocessor (CPU), the memory, the graphics processing unit (GPU), the keyboard, the mouse, the video card, the audio card, and hard drives, among others.
• the microprocessor CPU
• the memory the memory
• the graphics processing unit GPU
• the keyboard the mouse
• the video card the audio card
• hard drives among others.
• a second layer 1 1 arranged at a higher level is the operating system, which has the necessary drivers to communicate and interact in a bidirectional way (it can send and / or receive information from these resources, such as control signals 14 or data 15) with the resources of the lower layer 10.
• a third layer 12 arranged above the representative layer 1 1 of the operating system are the programming interfaces of applications (better known as API), both those that come within the operating system and those that are the result of the installation of the drivers of a lower layer resource 10. Normally, you are AP! they are implemented within dynamic link libraries, whatever the operating system used.
• the communication between the layer 12 comprising the APIs and the representative layer 1 1 of the operating system is also bidirectional, being able to exchange both control signals 14 and data 15.
• Figure 4 also shows a fourth layer or higher level layer 13 representing the running application. This application, during its execution, accesses the representative layer 12 of the APIs, exchanging both control signals and data.
• the running application 13 if, for example, the running application 13 requires the generation of a window on the display screen of the computer system on which it is running, the application must access certain services API 12 (whether functions or methods) intended for window generation. These services, in order to generate the window on the screen, need to exchange information (control signals and data) with the operating system 1 1, which has the necessary tools (i.e. controllers) to communicate with the screen 10 and cause , thus, the generation of the desired window.
• these services in order to generate the window on the screen, need to exchange information (control signals and data) with the operating system 1 1, which has the necessary tools (i.e. controllers) to communicate with the screen 10 and cause , thus, the generation of the desired window.
• each hardware resource of the computer system is only usable by a single application that is the one that the user has (or the operating system has selected as) active in the foreground (that is, the active window) , that is, if the hardware resource is the audio card, only the application that the user has active in the foreground, among all the applications that are running at that time, will be able to use that resource and therefore , will be the only one capable of sending audio data to the audio card for playback.
• the hardware resource is capable of receiving data from different running applications, but in that case it It will produce a mix of the data.
• the audio card reproduces a mixture of the different audio data it receives.
• the invention provides a piece of executable code that must be injected into each application at the time of starting its execution (for example, starting the process belonging to the application in a suspended state), which is capable of executing a procedure. to virtualize one or more hardware resources associated with a computer system on which the application runs.
• the main objective of this piece of code is to virtualize the hardware resources that the application requires of the computer system for its execution, so that it is capable of generating virtualized hardware resources usable only by the application in whose process it has been injected and manage the data flow between the process belonging to the application and the hardware resource.
• each running application has its own virtualized hardware devices, as well as a tool (the piece of code) that is capable of managing the data flows that are generated between them and the process.
• Figure 2 shows a diagram based on that of Figure 1 but also comprising a layer 16 representing the piece of executable code that, after being injected into the process associated with the application, is arranged at a logical level between layer 13 of the application and layer 12 representative of the
• the piece of code can intercept the calls of the application to certain services (for example, functions or methods) of the APIs and thus virtualize the hardware resources 10 '.
• the main function of layer 16 representing the piece of code is to intercept the different calls that the process belonging to the application makes to API services related to the data flow generated between the process and the hardware resources of the computer system, and, from the interception of these calls, manage the flow of data that occurs between the process and the hardware resources of the computer system, as well as between the process and the virtualized hardware resources 10 'described above.
• the procedure that executes the piece of code is as follows. For its description, it starts from an initial situation in which, when a user runs an application, the process belonging to the application starts in a suspended state. During this suspension state, the executable code piece is injected into the process. Once the piece of code is injected into the process, this piece of code loads into memory all those dynamic link libraries that contain the application programming interfaces (APIs) that contain services (whether functions or methods) related to the management of the data flow between the process and the different hardware resources of the computer system and that will be required by the application during its execution.
• APIs application programming interfaces
• the piece of code is able to intercept the calls that the process makes to these relevant services for its execution, that is, the calls that the process makes to the different relevant services of the different APIs are received by the code piece, since the pointers do not point to the API services but to the corresponding services included in the code piece.
• the piece of code acquires the ability to manage the flow of data that occurs between the process and the hardware resource of the computer system, that is, the piece of code takes control, transparently for the process, of the data flow that occurs between the process and the hardware resource of the computer system. More specifically, when the process intends to access a hardware resource of the computer system through calls to certain API services, the piece of code executes its own services (that is, it intercepts these calls). From this interception, to take control of the data flow it is necessary to generate a virtualized hardware resource 10 'that corresponds to the hardware resource of the computer system to which the process intends to access, if it had not been previously generated . The generation of the virtualized hardware resource 10 'can involve several actions.
• a first action may be to generate at least one buffer that virtualizes the at least one buffer associated with the hardware resource of the computer system, that is, the piece of code reserves a specific memory area, which represents the virtualized buffer, in the that the process must store the data that it is initially sending to the hardware resource of the computer system, but that have been intercepted by the piece of code.
• a second action to be performed may be to generate an execution thread that emulates the behavior of the hardware resource of the computer system. Basically, this thread of execution can be a function included in the code piece itself.
• the piece of code for the thread of execution (which is a function included in the same piece of code and, therefore, over which it has control) for a predetermined time (approximately for a few milliseconds), to later read the data stored in the virtualized buffer (remember that they come from the process) and process them.
• the code piece has the ability to send it to a first remote computer system, although this embodiment will be described later. It is important to note that it will normally be necessary for the piece of code to communicate to the process that the data has been received correctly, as would happen if the hardware resource was not virtualized but the one of the computer system itself.
• the generated execution thread receives data from a second remote computer system (although normally the first and second remote computer systems will be the same remote computer system). In this situation, the execution thread processes the received data and stores it, after processing, in the virtualized buffer that is part of the virtualized hardware resource 10 '.
• the process calls a certain service from an API to verify if the hardware resource of the computer system has generated data for the application. Since all API services related to data flow management between the process and system hardware resources have been redirected, the call is received by the code piece (more specifically a service included in the code piece) and processes it. To do this, the code piece retrieves the data contained in the virtualized buffer (remember that the data corresponding to the data contained in the virtualized buffer (that is, the data received and processed by the execution thread) have been received by the thread of execution of a remote computer system) and sends them to the process, so that it uses them.
• the code piece retrieves the data contained in the virtualized buffer (remember that the data corresponding to the data contained in the virtualized buffer (that is, the data received and processed by the execution thread) have been received by the thread of execution of a remote computer system) and sends them to the process, so that it uses them.
• the piece of code must periodically verify whether There is data in the buffer of the hardware resource and, if positive, delete it. In this way, problems are avoided during the execution of the application.
• the operating system is any one of the Windows family, for example, Windows 7;
• the computer system is an application server, more specifically games;
• the applications to be executed are games and / or different instances of the same game;
• the hardware resource on which a running game makes an access request is the audio card of the game server.
• An embodiment of the invention is described below in which the hardware resource is a video card, an embodiment of the invention in which the hardware resource is a data input device (eg, a keyboard or a mouse) , and an embodiment of the invention in which the hardware resource is a hard disk,
• the game server aims to allow service users to play different games or even the same game (for example, computer games (PC) or consoles) from their mobile terminals or remote computer systems, such as smartphones or tablets .
• the execution of each game or of each instance of the same game can be sent by means of streaming techniques from the game server to the mobile devices of the users.
• a user from his mobile device, can select the game to which You want to play, requesting its execution by acting on a control element (for example, a representative icon of the game) present in a graphical user interface shown on the screen of your mobile terminal.
• This user action on the control element generates a control signal towards the game server that causes the execution of the selected game, on the server.
• the present invention aims to make each game, based on the piece of code it has injected, You can virtualize the hardware resources of the game server that you require for its execution and thus dispose of them exclusively.
• the main process of the running application ie the game
• the CreateProcess function assigning the creation mode parameter (CreateFlags) the CREATE_SUSPENDED value.
• the injected code piece redirects the functions of the APs! related to the management of the data flow that occurs between the application (or more specifically the process belonging to the application) and the different hardware resources of the game server (in the present embodiment, at least those functions intended to manage data flow between the application and the audio card).
• the interesting functions could be lAudioClient or lAudioRenderClient.
• the operating system running on the game server is one of the Windows family (more specifically, Windows 7), these APIs described are normally implemented within dynamic link libraries (DLLs), for this reason , the piece of code loads, using the LoadLibrary function, the library or libraries that contain the interesting functions, for example, GeiBuffer and Re ⁇ easeBuffer of the ⁇ AudioRenderCiient API, through the library dxgi.dü.
• LoadLibrary loads the library into memory and the operating system populates the Index Address Table (! AT), which is a table of pointers to the API functions, with the initial addresses in memory of the AP! Functions.
• the code piece modifies the necessary pointers making them correspond to the functions included in the code piece injected in the process.
• the original content of the table that is, the initial value of the pointers before the modification, is saved in a variable in case the piece of code has to call at any time to any of the original redirected functions.
• the process calls for the creation of an interface of the ⁇ AudioRenderClient type (it is a COM type interface) by means of the GetService method of the ⁇ AudioCüent interface
• the piece of code verifies if this interface has already been modified (that is, redirected) or not by the piece of code.
• the table of method pointers of a COM type interface is modified with specific code.
• GetBuffer corresponds to position 4 of the method table of the ⁇ AudioRenderClient interface and must be modified to point to the function included in the injected piece of code.
• the original content of this position is saved in a variable in case the original method has to be called.
• the modification of the table of pointers of an interface of type COM only has to be done the first time an object of that type is created.
• AudioRenderClient to request a buffer in which to write the audio data for the audio card (more specifically, ask for the address of the memory area where you have to write the audio data)
• the code piece intercepts this call (Remember that the GetBuffer method is redirected to a corresponding method included in the piece of code, so the process really calls the corresponding method included in the piece of code).
• the corresponding method included in the code piece calls the original API method (although the code piece could comprise the entire method) and generates a buffer that virtualizes the buffer associated with the audio card, that is, the method an address of a memory zone in which the application wants to write the audio data is passed to the process. In this way, the process does not store the audio data in the buffer of the game server's audio card but in the virtualized buffer that corresponds to the actual card's buffer.
• the application writes all of the audio data in the virtualized buffer, it makes a call to the ReleaseBuffer function to indicate that it has finished writing the audio data and how much it has written. This call is again intercepted by the piece of code, so that it is possible to know when all the audio data has been written in the virtualized buffer and how much audio data has been written.
• the piece of code sends a buffer of the same size to the audio card, which only includes silence. In this way, the piece of code ensures that the audio card continues to control the application correctly.
• the piece of code generates an execution thread that simulates the behavior of the game server's audio card. It is important to indicate that this thread of execution is nothing more than a function included in the same piece of code.
• the piece of code for the execution of the thread for approximately a few milliseconds, either synchronously or asynchronously.
• the execution thread reads the audio data stored in the virtualized buffer from the process, processes it and sends it to! ends! Mobile for playback.
• Processing of the audio data may comprise mixing different audio data (for example, the music that is heard in the background during game execution and the audio that is heard by the intervention of the user about the game (for example, shooting, car engines, swords, etc.)) and convert them to a suitable audio format such as mp3 (refers to MPEG-1 Audio Standard, layer III).
• mp3 refers to MPEG-1 Audio Standard, layer III.
• a request for access by the game to the audio card has been described.
• a plurality of games and / or a plurality of instances of the same game may be running on the game server, so that each of them must comprise a piece of code injected to execute the described procedure.
• the procedure to virtualize the video card is as follows.
• the injected piece of code redirects the functions of the necessary APIs, in this case, for example, the ShowWindow or CreateDevice function of the DirectX API.
• the main objective of this procedure is for the piece of code to take, transparently, the management of the data flow that occurs between the video card and the process belonging to the application.
• these APIs are implemented within dynamic link libraries (in the present embodiment in which the operating system is one of the Windows family, these libraries are DLLs). Therefore, the piece of code loads, using the LoadLibrary function, the library or libraries that comprise the functions to be redirected, for example the ShowWindow function through the user32.dll library.
• the code piece Once loaded, and after the operating system has filled in the Index Address Table (IAT) with pointers to the API functions from the initial memory addresses in which these functions are stored, the code piece, Using the RedsrectA ⁇ T function, modify the pointers of those functions that may be interesting to vortex the video card. To do this, it replaces the initial memory addresses in which these API functions are stored with the initial memory addresses in which the corresponding functions included in the code piece are stored.
• the IAT could also be modified with specific code if necessary.
• the table of method pointers of a COM type interface is modified with specific code.
• Present corresponds to position 18 of the method table of the IDirect3DDevice9 interface and must be modified to point to the corresponding function included in the code piece.
• the original content of this position is saved in a variable in case the original method has to be called from the code piece.
• the modification of the table of pointers of an interface of type COM only has to be modified the first time an object of that type is created. At the time that the interception ends, that is, all the functions of all the APIs necessary to perform the virtualization of resources have been redirected, the piece of code is responsible for resuming the execution of the application process.
• DC Drawing Context
• the DC can be defined as a memory area in which the video card will store the resulting graphics per frame and is always associated with a window in
• the video virtualization thread captures the content of the DC. This can be done synchronously or asynchronously with the application.
• Synchronously means that when the process makes a request for access to the video card by invoking the Present method of the iDirect3DDevice9 interface to display the generated frame, the piece of code intercepts this Present method. At that time, the execution thread accesses the DC (in this case it is called BackBuffer), to capture the generated frame. Subsequently, if necessary, the piece of code calls the original Present method of the interface. This procedure is synchronized because there is a point, when the Present method is called, in which the piece of code knows perfectly well that the work to be done to draw the frame is finished.
• the asynchronous way is to directly access the DC of the window (where the video card leaves the result of generating the frame) to access its content. It must be taken into account that access to this DC must be carried out in mutual exclusion. For this, the thread of execution tries to gain access, by means of a survey, to this zone of mutual exclusion. When it succeeds, access the contents of the DC to capture the result of the generated frame. This method is asynchronous since the capture rate and the frame generation rate do not have to be the same.
• the processing of this information begins, which can be based on its coding by means of a suitable codec, such as H.264 and Send this coding online.
• a suitable codec such as H.264 and Send this coding online.
• the hardware resource is a data entry element, such as a mouse or keyboard
• the specific procedure is as follows. Unlike what has been described so far, this procedure manages a flow of data that goes from the data entry element to the process belonging to the application, that is, the procedure aims to deliver the orders of the user who is enjoying the game (by for example, through the touch screen or the keyboard of the mobile terminal), to the game that is running on the game server, for its evolution.
• the piece of code has redirected the appropriate services and generated the virtualized hardware resource (it is that is, it has generated a buffer that virtualizes the buffer of the data entry element, as well as an execution thread that emulates the behavior of the data input element), the piece of code (more specifically, the execution thread that simulates the behavior of the input element) receives data from the user's mobile terminal, which must be sent to the process so that it modifies, for example, the data related to audio and video, which will then be sent to the mobile terminal. For this, the code piece, depending on the input element from which it receives the data, stores this received data in the corresponding virtualized buffer (either that corresponding to the virtualized keyboard or the virtualized mouse).
• the code piece intercepts this call and causes the service corresponding included in the code piece, so that this service reads the data stored in the virtualized buffer and not in the actual input element buffer.
• the execution thread that emulates the message queue receives the data inputs (for example keyboard or mouse) from the remote system (i.e., the mobile terminal) through the network (for example Internet).
• This data can be orders and / or events that the user sends from the mobile terminal.
• the execution thread introduces a message in the message queue (using the SendMessage and PostMessage functions of the user32.dll library) associated with the application window.
• This message queue is the one that queries the application automatically using the message queue system mechanism offered by the operating system.
• the query and handling function of the message queue may be changed (using the SetWindowLongPtr function of the user32.dl ⁇ library) so that, instead of executing the Original message handling function of the message queue (also known as a procedure or window function, which is a function defined by the programmer to determine the behavior of the application in the case of a given message) is a function of the code piece Let it run. That is, the window procedure or function of the window corresponding to the application is intercepted.
• the Original message handling function of the message queue also known as a procedure or window function, which is a function defined by the programmer to determine the behavior of the application in the case of a given message
• said function of the piece of code can: eliminate those messages that the original function of the application window is not intended to treat (that is, do not perform any action on the message) and thus achieve that the application ignore these messages since the original function does not handle them; or, from the function of the code piece, call the original message handling function, since it is desired that the application reacts to these messages both because they are messages that the thread of execution of the code piece has entered which emulates the virtualized hardware resource that enters data (keyboard or mouse) from orders sent by the mobile terminal, such as because they are messages that do not alter the behavior of the application from the user's perception of the mobile terminal (the window has moved on the screen of the actual computer system, but this position is totally irrelevant for the user of the remote system).
• the procedure is as follows.
• the piece of code has already been injected into the process.
• the injected code piece redirects all the required functions of the APIs, for example CreateFile and CreateDirectory.
• the main objective is for the piece of code to take control of the data flow between the process and the hard disk.
• LoadLibrary loads the library that contains the functions to redirect, for example CreateFile and CreateDirectory from the kernel32.dll library.
• the operating system fills the! AT with the initial memory address in which each of the API functions is stored.
• the RedirectlAT function the necessary pointers are modified making them point to the corresponding functions included in the code piece.
• the code piece ends the redirection of the functions relevant to the management of the data flow between the process and the hard disk, the code piece itself is responsible for resuming the execution of the process belonging to the application that had been started in a suspended state.
• the code piece intercepts this request and executes the corresponding function included in the code piece. From the interception, this function verifies if the file that the process wishes to open is a game game file or is any other file. In the case that it is a file of the game, the function modifies, if necessary, the path to the file that you want to create and / or open using any kind of algorithm. Once the route has been modified, the original CreateFile function is executed with the new route created, although a corresponding function included in the piece of code could also be executed.
• the procedure to create a directory using the CreateDirectory function is equivalent to that described for CreateFile,
• the virtualization of each hardware resource has been described separately.
• the first stages of the procedure for example the one to load in memory the different dynamic link libraries or to replace the pointers to the services, can be common, that is, they can be loaded into memory at the same time all dynamic link libraries that include AP! with services relevant to all hardware resources that the piece of code is capable of virtualizing, as well as replacing the pointers of all services that must be redirected so that the piece of code can virtualize all hardware resources that it is capable of virtualizing,
• the described embodiments of the invention with reference to the drawings comprise computer systems and processes performed in computer systems
• the invention also extends to computer programs, more particularly to computer programs in or on carrier media. , adapted to put the invention into practice.
• the computer program may be in the form of source code, object code or intermediate code between source code and object code, such as partially compiled form, or in any other form suitable for use in the implementation of the agreement processes.
• the carrier medium can be any entity or device capable of carrying the program.
• the carrier medium may comprise a storage medium, such as a ROM, for example a CD ROM or a semiconductor ROM, or a magnetic recording medium, for example a floppy disc or a hard disk.
• the carrier means may be a transmissible carrier medium such as an electrical or optical signal that can be transmitted via electrical or optical cable or by radio or other means.
• the carrier medium may be constituted by said cable or another device or medium.
• the carrier means may be an integrated circuit in which the computer program is encapsulated (emhedded), said integrated circuit being adapted to perform, or to be used in the realization of, the relevant processes.

Landscapes

• Engineering & Computer Science (AREA)
• Software Systems (AREA)
• Theoretical Computer Science (AREA)
• Physics & Mathematics (AREA)
• General Engineering & Computer Science (AREA)
• General Physics & Mathematics (AREA)
• Stored Programmes (AREA)
• Devices For Executing Special Programs (AREA)
• Debugging And Monitoring (AREA)

Priority Applications (7)

Applications Claiming Priority (2)

Publications (1)

Family

ID=49382969

Family Applications (1)

Country Status (9)

Cited By (2)

Families Citing this family (17)

Citations (3)

Family Cites Families (13)

• 2012
  • 2012-04-19 ES ES201230581A patent/ES2439804B1/es active Active
• 2013
  • 2013-04-18 CN CN201380031256.2A patent/CN104380256B/zh active Active
  • 2013-04-18 EP EP13778383.3A patent/EP2840497B1/en active Active
  • 2013-04-18 HU HUE13778383A patent/HUE049385T2/hu unknown
  • 2013-04-18 DK DK13778383.3T patent/DK2840497T3/da active
  • 2013-04-18 JP JP2015506269A patent/JP2015517158A/ja active Pending
  • 2013-04-18 KR KR1020147032268A patent/KR102059219B1/ko active Active
  • 2013-04-18 ES ES13778383T patent/ES2798184T3/es active Active
  • 2013-04-18 WO PCT/ES2013/070247 patent/WO2013156654A1/es not_active Ceased
  • 2013-04-18 US US14/395,479 patent/US9176757B2/en active Active

Patent Citations (3)

Non-Patent Citations (4)

Also Published As

Similar Documents

Legal Events