JP2015041273A - Program update system, program update method, program update program, and communication device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To execute the correction of a plurality of functions having a dependence relation without stopping communication and bringing about malfunction of a system.SOLUTION: A program update system substitutes functions called via an intermediate table by a main body program, with corrected functions, and a plurality of functions have a dependence relation. When substitution is activated, a call to a function which the main body program tries to first call, out of the plurality of functions having a dependence relation is inhibited, and a stack in each thread in the main body program is traced to confirm whether there is a thread calling a function that is a substitution object or not. If there is a thread calling the function, the call inhibition state is released to complete the execution of the function call in the thread, and then the call inhibition state is restored. Thereafter, an address of the function in the intermediate table is rewritten with an address of a corrected function, and then the call inhibition state is released.

Description

  The present invention relates to a program update system, a program update method, a program update program, and a communication apparatus. For example, an access gateway that is a gateway for an access network to an IP (Internet Protocol) network that collects a plurality of subscriber lines. It can be applied to Access Gateway (AGW).

  Processing in the access gateway is mainly performed by executing software (access gateway program) by the CPU. In addition, the access gateway is required to always support communication.

  Since the access gateway program that causes the access gateway to function as an access gateway is a program, it is necessary to upgrade the version as appropriate. However, it is necessary to upgrade the version under the restriction that the communication is always supported.

  As a method for updating a program component or a unit (referred to as a function here) without stopping execution of the program, a method described in Patent Document 1 or Patent Document 2 (hereinafter also referred to as a plug-in method). There is). This plug-in method includes pre-processing performed at the time of program startup (at the time of building) and update processing main body performed at the time of updating.

  When building a program, the function name of the global function is extracted from the generated object file using the nm command (command type used in UNIX (registered trademark) and similar operating systems), and an intermediate table is created for each function. And make it a shared library. Then, when the program is executed and the library is loaded, the address of the function mapped in the memory is resolved and set in the intermediate table.

  At the time of execution of a normal program, as shown in FIG. 6A, when a function (funcA in FIG. 6) is executed by the main body program 41, it is set in the intermediate table 42 via the intermediate table 42. The function call is realized by jumping to the address 0xabcdabcd of the function library 43.

  With the configuration via the intermediate table 42 as described above, the function can be updated without stopping the execution of the program.

  When the function is updated, as shown in FIG. 6B, a partial program related to the corrected function is created in advance as a shared library (plug-in library) 44, and the plug-in library 44 is dynamically created by a plug-in application command. The address of the corrected function is resolved, and the address of the library of the corresponding function in the intermediate table 42 is rewritten to the address 0x01230123 of the plug-in library 44.

  By rewriting the address in the intermediate table 42, the corrected function funcA is executed from the next function call.

JP 2005-284925 A JP 2010-130620 A

  However, the conventional plug-in method described above may not operate normally when applied to updating a function having a dependency relationship with another function.

  FIG. 7 shows a case where such a problem occurs.

  For example, assume that two functions of funcA and funcB are modified and a plug-in method is applied. The two functions funcA and funcB have a dependency relationship that the function funcB is called from the function funcA. Further, the correction process of the function funcB is essential for the correction process of the function funcA, and the correction process of the function funcA is essential for the correction process of the function funcB.

  In the conventional plug-in method, by executing the rewriting process of the intermediate table 42 with one instruction, it is guaranteed that the corresponding function is not activated during the rewriting of the intermediate table 42 for one function. . However, as in this example, the functions funcA and funcB are not executed at the time of plug-in input (when the correction library is loaded), and the functions funcA and funcB until plug-in application completion (correction processing is completed). Cannot be guaranteed not to run. Therefore, an event such as execution of the function funcB after correction from the function funcA before correction may occur, and there is a possibility that the function does not operate normally. That is, as shown in FIG. 7, the plug-in is applied during the execution of the function funcB before the correction and before the execution of the function funcB before the correction, and the jump destination address when the function funcA is executed and the jump when the function funcB is executed. When the destination address is rewritten, since the function funcA before correction is already being executed, when the function funcB is read by the execution, the function funcB after correction is read out, and the function funcA before correction and the function after correction are corrected. The function funcB does not operate normally due to inconsistency with the function funcB. In the worst case, the program may end abnormally, and this does not satisfy the constraint that the communication is always supported.

  In the access gateway, a plurality of call processing threads execute call processing asynchronously, and therefore, the functions funcA and funcB before correction to be corrected are not executed when the plug-in is applied (when the correction library is loaded). It is difficult to guarantee this, and for this reason, in conventional access gateways, it has been impossible to apply corrections using a plug-in method for a plurality of functions having such dependency relationships.

  Therefore, a program update system, a program update method, a program update program, and a communication device that can appropriately execute correction of a plurality of functions having a dependency relationship without stopping communication are desired.

  The first aspect of the present invention is a program that replaces a function, which is a program part that is called by a main body program via an intermediate table, receives data called an argument, executes a predetermined process and returns a result, with a corrected function. In the update system, (1) a call deterring means for deterring a call to the highest-level dependence source function that the main body program calls first among a plurality of functions having a dependency relationship at the time of replacement activation; ) Trace the stack of each thread built in the main program, check if there is a thread that is calling the function to be replaced, and if there is a thread that is calling the function to be replaced, release the suppression state. Function non-execution guarantee means for completing the execution of the calling function for the thread and returning it to the inhibited state, and (3) calling the function to be replaced Address rewriting means for rewriting the address of the function in the intermediate table from the address of the function before modification to the address of the function after modification in the absence of a thread, and (4) the highest level from the main body program after rewriting the address. Call suppression canceling means for canceling the call suppression state of the dependency source function.

  The second aspect of the present invention is a program that replaces a function, which is a program part that is called by a main body program via an intermediate table, receives data called an argument, executes a predetermined process and returns a result, with a corrected function. In the update method, (1) a call suppression step for suppressing a call to the highest-level dependency source function that the main body program tries to call first among a plurality of functions having a dependency relationship at the time of replacement activation; ) Trace the stack of each thread built in the main program, check if there is a thread that is calling the function to be replaced, and if there is a thread that is calling the function to be replaced, release the suppression state. A function non-execution guarantee step that completes the execution of the calling function for the thread and returns it to the inhibited state, and (3) calls the function to be replaced An address rewriting step of rewriting the address of the function in the intermediate table from the address of the function before the modification to the address of the function after the modification in the state where there is no thread in the intermediate table, and (4) after rewriting the address, And a call inhibition release step for releasing the call inhibition state of the highest-level dependent source function.

  The third aspect of the present invention is a function that replaces a function that is a program part that is called by a main body program via an intermediate table, receives data called an argument, executes a predetermined process and returns a result, with a corrected function. (1) At the time of replacement start, among the multiple functions that have dependencies, the computer program suppresses calls to the highest dependency source function that the main body program tries to call first (2) Trace the stack of each thread built in the main program, check if there is a thread calling the function to be replaced, and if there is a thread calling the function to be replaced A function non-execution guarantee means that divides the suppression state, completes execution of the calling function for the thread, and returns to the suppression state; and (3) a replacement target An address rewriting means for rewriting the address of the function in the intermediate table from the address of the function before modification to the address of the function after modification in a state where there is no thread calling the function; and (4) after rewriting the address, It is made to function as a call suppression release means for canceling the call suppression status of the highest-level dependent source function from the program.

  A communication apparatus according to a fourth aspect of the present invention includes the program update system according to the first aspect of the present invention.

  According to the present invention, correction of a plurality of functions having a dependency relationship can be appropriately executed without stopping communication.

It is a block diagram which shows the functional structure of the access gateway (communication apparatus) of embodiment. It is the block diagram which described the detail of the access gateway of embodiment from the hardware-like structure side. It is explanatory drawing which shows the structure of the program for AGW memorize | stored in the access gateway of embodiment. It is explanatory drawing which shows the outline | summary of the operation | movement which replaces the library in the access gateway of embodiment with the corrected library. It is a flowchart which shows the operation | movement which replaces the library in the access gateway of embodiment with the corrected library. It is explanatory drawing of the conventional plug-in system which updates the component and structural unit of a program. It is explanatory drawing of the subject of the conventional plug-in system.

(A) Main Embodiment Hereinafter, an embodiment in which a program update system, a program update method, a program update program, and a communication apparatus according to the present invention are applied to an access gateway will be described with reference to the drawings.

(A-1) Configuration of Embodiment FIG. 1 is a block diagram showing a functional configuration of an access gateway. The access gateway 1 has a gateway function for connecting a plurality of telephone terminals 2 (only one is described in FIG. 1) to the IP network 3. The access gateway 1 includes a voice control unit 10 that terminates the telephone terminal 2, a network interface unit 11 that takes charge of an interface with the IP network 3 side, and a telephone terminal 2 that controls and accommodates the network interface unit 11 and the IP. A connection control unit 12 that controls connection with the network 3 and the like is included.

  Here, the voice control unit 10, the network interface unit 11, and the connection control unit 12 mainly execute functions for which they are responsible by software processing.

  FIG. 2 is a block diagram described from the hardware configuration side of the access gateway 1, unlike FIG. 1.

  In the access gateway 1, an input unit 22, an output unit 23, a communication unit 24, an external storage device 25, and the like are connected to the control unit 20 via an interface unit (IF) 21. In addition, an input / output port 16 is provided so that a maintenance terminal (not shown) can be connected. The control unit 20 includes a CPU and various memories (ROM, RAM, etc.) that are accessed when the CPU executes processing, and a part of the memory is used as a so-called main memory. The external storage device 25 includes, for example, a recording medium such as a hard disk or a CD-ROM and its access configuration, and stores a program and the like loaded into the main memory of the access gateway 1.

  The external storage device 25 stores an AGW program for operating as a group AGW to be loaded into the main memory when the access gateway 1 is started up. FIG. 3 is an explanatory diagram showing the configuration of the AGW program stored in the external storage device 25.

  The AGW program 30 is divided into a plurality of modules. The module includes a main module 31 and a dynamic link library module (hereinafter referred to as a DLL module) 32 (32-a to 32-n). The main module 31 is a so-called executable file and is loaded into the main memory by the OS. The DLL module 32 is read by the main module 31 (executable file) and loaded into the main memory. It should be noted that the type of processing related to the DLL module 32 (for gateway processing, fault processing, etc.) and the type of program (resident program, non-resident program, subroutine, etc.) can be distinguished from the identifier (name) of the DLL module 32. Has been made.

  Since the DLL module 32 is a library, a plurality of highly versatile program parts are grouped in a reusable form. The program portion accommodated in the library is a so-called function that is a series of instructions that receive data called an argument, execute a predetermined process, and return a result. The same DLL module 32 (library) may include a group of functions having a dependency relationship. That is, other functions called by a certain function may be included in the same DLL module 32 (library). The access gateway 1 performs call processing related to the telephone terminal 2 accommodated therein. In many types of call processing, the state of other types of call processing is often a start condition, and the DLL module 32 ( Library) often includes functions with dependencies.

  In addition to the main body program 31A and the intermediate table 31B (see FIG. 4) that function as the AGW, the main module 31 newly establishes the access gateway 1 as a processing routine for operating the DLL module 32 as shown in FIG. When loaded, the initial startup load routine 31C for loading a predetermined DLL module described in itself into the main memory, or a modified new module (or new program) is loaded into the main memory. And an update routine 31D for unloading old modules (or old programs) that are no longer necessary due to the modification from the main memory.

(A-2) Operation of Embodiment Next, the operation of replacing the library (in other words, the function belonging to it) in the access gateway of the embodiment with a modified version will be described with reference to the drawings. Such a correction operation is executed by the update routine 31D of the main module 31 which is a program update program.

  FIG. 4 is an explanatory diagram showing an outline of the operation of replacing the library according to this embodiment with a modified library (plug-in library).

  As described above, the main module 31 (not shown in FIG. 4) includes a main body program 31A and an intermediate table 31B that function as an AGW. The main body program 31A includes threads 35-1 to 35-X that are generated for each unit that manages and distinguishes processing such as a line with the telephone terminal 2 that is used for call processing. Each of the threads 35-1,..., 35-X manages function call information as stack information. FIG. 4 shows a case where two functions funcA and funcB belong to the library libA, and shows a case where a plug-in library pluglibA obtained by modifying the library libA is already installed.

  In such a state, when the update routine 31D of the main module 31 is activated, a replacement process from the library libA to the plug-in library pluglibA is started.

  Although not shown in FIG. 4, the dependency that requires the function funcB to be called during the execution of the function funcA is input before the maintenance staff instructing the correction starts the update routine 31D. Also, dependency information is managed by a part of the library libA to be replaced or the plug-in library pluglibA to be replaced, and an activated update routine 31D (more precisely, a control unit that executes the update routine 31D) Hereafter, there are places that are also expressed in the same manner), it may be possible to read the dependency information managed immediately after startup, and the dependency information is managed by the main body program 31A or the intermediate table 31B. Then, the activated update routine 31D reads the dependency information managed immediately after the activation. May be useless, In addition, the update routine 31D immediately after start-up may be to understand the function of dependency to interpret the library libA. FIG. 4 and FIG. 5 to be described later show processing after recognizing that the functions funcA and funcB are in a dependency relationship.

  First, the update routine 31D temporarily suppresses the call from the main body program 31A of the reference source function funcA in the dependency relationship (ST1).

  Thereafter, the update routine 31D sequentially traces the stack for all the threads 35-1 to 35-X, and the call information of the reference function funcA in the dependency relationship or the reference function funcB in the dependency relationship is stored in the stack. It is checked whether or not the call remains, and for the thread in which at least one of the function funcA and funcB call information remains in the stack, the temporary inhibition state is suspended, and the function funcA is executed including the execution of the function funcB. It is executed (ST2).

  When the stack trace for all the threads 35-1 to 35 -X and the execution completion process of the function associated therewith are completed, the update routine 31 D obtains the call addresses of the functions funcA and funcB in the intermediate table 31 B from the addresses in the library libA. The address in the plug-in library pluglibA is rewritten (ST3).

  Finally, the update routine 31D releases the temporary inhibition of the call from the main body program 31A of the reference function funcA in the dependency relationship (ST4).

  FIG. 5 is a flowchart showing an operation (main part of the update routine 31D; program update program) for replacing the library in this embodiment with a modified library (plug-in library). FIG. 5 shows a flow of operations similar to FIG. 4, but from the viewpoint of the flow of processing by the update routine 31D. In the following, the operating subject of FIG. 5 is the control unit 20 (CPU). Will be described.

  When the processing shown in FIG. 5 is started, the control unit 20 first temporarily stops the call (jump) of the reference source function funcA in the dependency relationship from the main body program 31A (step 100).

  Thereafter, the control unit 20 checks whether or not an unprocessed thread remains. If an unprocessed thread remains, one of them is set as a processing target (step 101S). Then, it is checked whether the call information of at least one of the reference source function funcA in the dependency relationship or the reference destination function funcB in the dependency relationship remains in the stack of the processing target thread (step 102).

  When neither the function funcA call information nor the function funcB call information remains in the stack of the processing target thread, the control unit 20 performs a process of confirming whether an unprocessed thread remains (step 101E).

  On the other hand, when the call information of at least one of the function funcA or the function funcB remains in the stack of the processing target thread, the control unit 20 temporarily stops calling the function funcA from the main body program 31A (thread). After canceling (step 103), after waiting for the elapse of a predetermined time that can guarantee the time required for the processing of the function funcA (including the processing of the function funcB) (step 104), the function from the main body program 31A (thread) again. The calling of funcA is temporarily stopped (step 100).

  FIG. 5 shows that the next unprocessed thread is processed immediately after a predetermined time elapses. However, when the predetermined time elapses, the function funcA call information and the function funcB call information remain in the stack. After confirming that there is no thread, the next unprocessed thread may be set as a processing target. In the case of this modification, when it cannot be confirmed that no information remains in the stack, the above-described steps 103 and 104 are executed.

  When the processing for all the threads is completed and there are no unprocessed threads, the control unit 20 rewrites the call addresses of the functions funcA and funcB in the intermediate table 31B from the addresses in the library libA to the addresses in the plug-in library pluglibA (step). 105).

  Finally, the control unit 20 releases the temporary stop of the function funcA call from the main body program 31A (step 106), and ends the series of processes shown in FIG.

  Thereafter, when the body program 31A calls the function funcA, the modified function funcA on the plug-in library pluglibA is called via the intermediate table 31B.

(A-3) Effect of Embodiment According to the first embodiment, it is possible to appropriately replace a plurality of functions having dependencies with each other without stopping communication.

  To describe the effect more specifically, first, even when a plug-in is applied during the execution of the function funcA, an execution error of the program due to the execution of the function funcB after the correction from the function funcA before the correction Second, the plug-in is applied during the execution of the function funcB, and the function funcA after correction is processed in a state where the operation expected by the call of the function funcB after correction is not executed. An execution error of the program due to returning can be prevented.

(B) Other Embodiments In the above embodiment, a case where a function having two dependencies is replaced with a function modified by applying a plug-in library has been described. The present invention can also be applied to a case where a plug-in library is applied and modified.

  Moreover, although the case where the technical idea of this invention was applied to the access gateway was shown in the said embodiment, the technical idea of this invention is applicable also to another communication apparatus.

  DESCRIPTION OF SYMBOLS 1 ... Access gateway, 20 ... Control part, 30 ... AGW program, 31 ... Main module, 31A ... Main body program, 31B ... Intermediate table, 31C ... Initial startup load routine, 31D ... Update routine, 32-, 32-a ˜32-n... Dynamic link library module (DLL module), 35-1 to 35-X... Thread.

Claims (5)

In a program update system that replaces a function, which is a program part that a main program calls through an intermediate table, receives data called an argument, executes a predetermined process and returns a result, with a corrected function,
A call deterring means for deterring a call to the highest-order dependent source function that the main program first calls out of a plurality of functions having a dependency relationship at the time of replacement activation;
Trace the stack of each thread built in the main program, check if there is a thread that is calling the function to be replaced, and if there is a thread that is calling the function to be replaced, release the suppression state, A function non-execution guarantee means that completes the execution of the calling function and returns to the inhibited state;
An address rewriting means for rewriting the address of the function in the intermediate table from the address of the function before modification to the address of the function after modification, in a state where there is no thread calling the function to be replaced;
A program update system comprising: call suppression release means for canceling a call suppression state of the highest-level dependent source function from the main body program after rewriting the address. In a program update method in which a function that is a program part that is called by a main body program via an intermediate table, receives data called an argument, executes processing as defined, and returns a result, is replaced with a corrected function.
A call suppression step for suppressing a call to the highest-level dependency source function that the main program first calls out of a plurality of functions having a dependency relationship at the time of replacement start;
Trace the stack of each thread built in the main program, check if there is a thread that is calling the function to be replaced, and if there is a thread that is calling the function to be replaced, release the suppression state, A function non-execution guarantee step that completes the execution of the calling function for and returns it to the inhibited state
An address rewriting step for rewriting the address of the function in the intermediate table from the address of the function before modification to the address of the function after modification, in a state where there is no thread calling the function to be replaced;
And a call deterrence canceling step of canceling the call deterrence state of the highest-level dependent source function from the main body program after rewriting the address. Installed in a communication device equipped with a function that replaces a function, which is a program part that the main program calls through an intermediate table, receives data called an argument, executes the specified processing and returns the result, with a modified function Computer
A call deterring means for deterring a call to the highest-order dependent source function that the main program first calls out of a plurality of functions having a dependency relationship at the time of replacement activation;
Trace the stack of each thread built in the main program, check if there is a thread that is calling the function to be replaced, and if there is a thread that is calling the function to be replaced, divide the suppression state, A function non-execution guarantee means for completing execution of the calling function for the thread and returning it to the inhibited state;
An address rewriting means for rewriting the address of the function in the intermediate table from the address of the function before modification to the address of the function after modification, in a state where there is no thread calling the function to be replaced;
A program update program that functions as a call deterrence canceling unit that cancels the call deterrence state of the highest-level dependent source function from the main body program after rewriting the address.   A communication apparatus comprising the program update system according to claim 1.   The communication apparatus according to claim 4, wherein the communication apparatus is an access gateway.

Images