JP2008021067A - Tracing function adding method for image forming apparatus, its program, and image forming apparatus having this program installed - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To shorten the error analysis period by easily adding a tracing function to an image forming apparatus having no tracing function. <P>SOLUTION: A communication section 33 communicates with a controllers for controlling peripheral equipment such as a scanner 15 and printer 16 included in the image forming apparatus 10, and stores the received peripheral equipment state in a memory buffer. A replacement section 41 replaces a return command from a subroutine constituting the communication section 33 with a jump command to a program of a communication logging section 46 whose word length is not longer than that of the return command. This program makes a DRAM 13D store the contents stored in the memory buffer as communication information based on a light pointer 481, updates the contents of the light pointer 481 to the address for the next storage, and then changes a command pointer of a processor 11 to the return address by executing a return command. <P>COPYRIGHT: (C)2008,JPO&INPIT

Description

  BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an image forming apparatus having functions such as copying, printing, and facsimile, and in particular, a tracing function adding method and program for an image forming apparatus capable of adding a tracing function only when necessary, and the program installed The present invention relates to an image forming apparatus.

  At the program development stage of the image forming device, the debug option is enabled, the source code is compiled, the debug code is inserted, and the execution program is operated in combination with the debugger to investigate the cause of the error. This can be dealt with.

  In the test stage after the program is completed, tests are performed assuming various cases.

  At the commercialization stage, the debug option is disabled and the source code is compiled, thereby reducing the program size and preventing the processing speed from being delayed.

  However, it is almost impossible to test under all conditions including timing. If an error occurs after product shipment, the image forming apparatus is not equipped with a debugging function, so that error analysis takes a long time.

  In Patent Document 1, the decoding circuit determines where the access destination is based on the address accessed by the CPU, the access analysis circuit analyzes the content accessed by the CPU, and the log receiving / transmitting DMA performs the analysis. An image forming apparatus having a trace function for outputting an access analysis result is disclosed.

However, if the image forming apparatus is not provided with such a circuit, the operation leading to the error cannot be traced.
JP 2006-11969 A

  In view of such problems, an object of the present invention is to provide a trace function adding method for an image forming apparatus capable of shortening an error analysis time by easily adding a trace function to an image forming apparatus not provided with a trace function. And an image forming apparatus in which the program is installed.

  Another object of the present invention is to perform a debugging function by a user operation when an error occurs without delaying normal operation or increasing the program size and without providing a special circuit for tracing. Is to provide an image forming apparatus capable of shortening the error analysis time.

A first aspect of the present invention is an image forming apparatus trace function addition program for adding a trace function to a machine language program stored in a storage unit of an image forming apparatus, the first replacement program being stored in the storage unit And a first logging program, and the machine language program communicates with a controller that controls the peripheral device included in the image forming apparatus, and stores the received peripheral device state in a memory buffer. Have
The first replacement program causes the processor of the image forming apparatus or another processor to replace a return instruction from the communication subroutine with a jump instruction to the first logging program whose word length is less than or equal to the return instruction. Features
The first logging program is sent to the processor of the image forming apparatus.
The content stored in the memory buffer is stored as communication information in the storage means based on the first write pointer, the content of the first write pointer is updated to the address to be stored next,
Changing the instruction pointer of the processor to the return address;
Has steps.

In a second aspect of the trace function adding program for an image forming apparatus according to the present invention, in the first aspect, the program further comprises a second replacement program and a second logging program stored in the storage unit,
The second replacement program sends a return instruction from a subroutine other than the communication subroutine included in the machine language program to the processor of the image forming apparatus or another processor, and the second instruction having a word length equal to or less than the return instruction. 2 It is replaced with a jump instruction to the logging program,
The second logging program is sent to the processor of the image forming apparatus.
Obtaining a return address from a subroutine including a jump instruction replaced by the second replacement program;
Information related to the subroutine call instruction stored immediately before the return address is stored in the storage means based on the second write pointer, and the content of the second write pointer is updated to the address to be stored next,
Changing the instruction pointer of the processor to the return address;
Steps are provided to obtain time-series information of a combination of the device communication information and information related to the subroutine call instruction.

In the third aspect of the trace function adding program for an image forming apparatus according to the present invention, in the second aspect,
Further including address data in which an address of a return instruction from the communication subroutine and a return instruction from a subroutine other than the communication subroutine are described;
Both the first and second replacement programs cause the processor of the image forming apparatus or the other processor to replace the return instruction of the address included in the address data with the jump instruction.

In the fourth aspect of the trace function addition program for an image forming apparatus according to the present invention, in any one of the first to third aspects,
The first logging program further causes the processor of the image forming apparatus to add a communication ID to the communication information and store it in the storage means,
The second logging program further causes the processor of the image forming apparatus to add the communication ID to information related to the subroutine call instruction when the communication ID is newly added to the storage means. Store in the means.

In a fifth aspect of the trace function addition program for an image forming apparatus according to the present invention, in any one of the first to third aspects,
The second write pointer is identical to the first write pointer;
The second logging program further prohibits the processor of the image forming apparatus from interrupting the first logging program during its execution.

In a sixth aspect of the trace function addition program for an image forming apparatus according to the present invention, in any one of the first to fifth aspects,
The machine language program is generated by compiling a high-level language source program,
A function information table in which a function name in the source program corresponding to a subroutine in the machine language program is associated with an address of the subroutine;
The second logging program further causes the processor of the image forming apparatus to refer to the function information table so that a function name corresponding to a branch destination address that is an operand of the subroutine call instruction is obtained. As part or all of

In a seventh aspect of the trace function adding program for an image forming apparatus according to the present invention, in any one of the first to sixth aspects,
A reverse replacement program stored in the storage unit of the image forming apparatus;
The reverse replacement program causes the processor of the image forming apparatus to replace the jump instruction to the first logging program and the jump instruction to the second logging program, respectively, with a return instruction from a subroutine.

  According to the configuration of the first aspect, a communication subroutine for communicating with the controller that controls the peripheral device included in the image forming apparatus and storing the received peripheral device state in the memory buffer is provided in the machine of the image forming apparatus. A word program, and a first replacement program sends a return instruction from the communication subroutine to the processor of the image forming apparatus or another processor, and a jump instruction to the first logging program whose word length is less than or equal to the return instruction. The first logging program causes the processor of the image forming apparatus to store the contents stored in the memory buffer as communication information in the storage means based on the first write pointer, and to store the first write The contents of the pointer are updated to the address to be stored next, and the instruction pointer of the processor is updated to the return address. Since the calico, an effect that can be easily added trace function of the peripheral device operation in the image forming apparatus having no trace function, which makes it possible to shorten the error analysis time.

  In addition, since there is no need to add the trace function unless an error occurs, the normal operation is not delayed and the program size can be prevented from increasing.

  Furthermore, there is an effect that it is not necessary to provide a special circuit for tracing in the image forming apparatus.

  According to the configuration of the second aspect, the second replacement program sends a return instruction from a subroutine other than the communication subroutine included in the machine language program to the processor of the image forming apparatus or another processor. Is replaced with a jump instruction to the second logging program that is less than or equal to the return instruction, and the second logging program instructs the processor of the image forming apparatus from a subroutine including the jump instruction replaced by the second replacement program. Information about the subroutine call instruction stored immediately before the return address is stored in the storage means based on the second write pointer, and the contents of the second write pointer are stored next. And update the processor instruction pointer to the return address. In, the image forming apparatus further tracing subroutine units, can be added in association with trace function peripherals operation, thereby an effect that it is possible to further reduce the error analysis time.

  According to the configuration of the third aspect, it further includes address data in which an address of a return instruction from the communication subroutine and a return instruction from a subroutine other than the communication subroutine are described, and the first and second replacement programs have In any case, since the return instruction of the address included in the address data is replaced with the jump instruction for the processor of the image forming apparatus or the other processor, it is possible to trace only the function that needs to be traced. There is an effect.

  According to the configuration of the fourth aspect, the first logging program further causes the processor of the image forming apparatus to add a communication ID to the communication information and store the communication information in the storage unit. Further, when the communication ID is newly added to the storage unit, the communication ID is added to the information related to the subroutine call instruction and stored in the storage unit. Both logs can be associated and combined to avoid complications, and even if an interrupt that indirectly calls the communication subroutine is accepted, it is possible to avoid taking a communication log during function log acquisition. Play.

  According to the configuration of the fifth aspect, since the interrupt of the first logging program during execution of the second logging program is prohibited, the second write pointer can be made the same as the first write pointer. This is advantageous in that the configuration of the trace function is simplified.

  According to the configuration of the sixth aspect, the machine language program is generated by compiling a high-level language source program, and the function name in the source program corresponding to the subroutine in the machine language program , The subroutine address, and the second logging program further causes the processor of the image forming apparatus to refer to the function information table so that the subroutine call instruction is associated with the subroutine address. Since the function name corresponding to the branch destination address that is the operand of is acquired as part or all of the information related to the subroutine call instruction, an error analysis is facilitated.

  According to the configuration of the seventh aspect, the reverse replacement program sends a jump instruction to the first logging program and a jump instruction to the second logging program to the processor of the image forming apparatus, respectively. Therefore, by executing the reverse replacement program after tracing, it is possible to prevent the normal operation from being delayed and the program size from being increased even after the tracing.

  Other objects, configurations and effects of the present invention will become apparent from the following description.

  FIG. 8 is a schematic block diagram illustrating a hardware configuration of the image forming apparatus 10 according to the first embodiment of the invention.

  In this image forming apparatus 10, the MPU 11 is coupled to a ROM 13 R, NVRAM 13 N, DRAM 13 D, hard disk 14, scanner 15, printer 16, modem 17, NIC 18, and operation panel 19 via an interface 12. In FIG. 9, a plurality of interfaces are shown as one block for the sake of simplicity.

  The ROM 13R stores bootstrap and BIOS. The NVRAM 13N is, for example, a flash memory, and stores an operating system (OS), an application that operates on the upper layer of the OS, various device drivers that operate on the lower layer of the OS, and various setting values. The application includes an application for causing the image forming apparatus 10 to function as a multifunction peripheral. The functions include copying, scanning, printing, and facsimile. The DRAM 13D is for main memory. The DRAM 13D is also used for storing a tracer program to be described later when an unknown error occurs. The hard disk 14 is mainly used for data storage, and stores a log file to be described later.

  The scanner 15 is for image input for copying and fax transmission. The printer 16 includes a print engine, a fixing device, a paper feed unit, a conveyance unit, and a paper discharge unit, and generates an electrostatic latent image on a photosensitive drum of the print engine based on bitmap data supplied as print data. The toner is formed, developed with toner, transferred to a sheet, fixed, and discharged. The modem 17 is for fax transmission / reception. The NIC 18 is coupled to the host computer 20 on the network, and is used for print jobs, file access to the hard disk 14, and installation of the tracer program. The operation panel 19 is used for inputting a setting value or an instruction and displaying a setting screen or a state.

  If an unknown error occurs in the user usage stage, replacing all application programs with programs compiled with the debug option enabled and adding a debugger will take time, and the program size will become too large and memory will be increased. It must be added and is not practical.

  On the other hand, if the program flow when an error occurs can be grasped in units of functions, the cause of the error can be easily determined.

  Thus, in the first embodiment, a trace function is added to an existing machine program as follows.

   FIG. 3A shows the relationship between a main routine written in C language and a subroutine (function).

  In this example, when the function fnc1 (x0, y0) is called in the main routine and the return instruction of this function is executed, the process returns to the step next to the function call instruction in the main routine.

  FIG. 3B shows a machine language generated by compiling the source code shown in FIG. 3A and described in mnemonics. Since the compiler compiles according to a predetermined rule, there is a certain correspondence between the C language and assembly language programs with respect to function calls and return from functions to the main routine.

  That is, in the machine language for function calls, after the arguments x0 and y0 are loaded from the memory to the register eax, the contents of this register are pushed to the stack area by the push instruction. Next, the subroutine call instruction call fnc1 is executed, and the address of the instruction next to this instruction is returned as a return address. In the case of Pentium (registered trademark), it is pushed to the stack area, and in the case of PowerPC (registered trademark). After being stored in the link register lr (the same applies hereinafter), the program jumps to the address fnc1.

  In this function fnc1, arguments x0 and y0 are popped from the stack area from the stack area and used. The return address popped from the stack area or stored in the link register lr by the last return instruction ret of the function fnc1 (the return instruction in the case of PowerPC is a branch link register instruction blr, hereinafter simply referred to as a return instruction ret). Return to the main routine based on the address.

  In the first embodiment, as shown in FIG. 4, a function logging routine fncLogging is added to an existing machine language program, and the last return instruction ret of each function is replaced with an unconditional jump instruction jmp to this function logging routine. . Thereby, the last return instruction ret of the function logging routine plays the same role as the return instruction before replacement.

  In order to realize the first embodiment, the number of bytes of the unconditional jump instruction jmp is required to be less than that of the return instruction. This condition is satisfied with many processors.

  In the function logging routine, the original return address from the function fnc1 is obtained from the contents of the register obtained by executing the pop instruction or the contents of the link register. By subtracting the number of bytes of the subroutine call instruction from this address, the address of the subroutine call instruction is obtained. When this pop instruction is executed, the contents of the stack pointer register are returned to the values before the pop instruction is executed.

  Further, this address is traced back to detect the regular use count n of the push instruction, or the value of n is obtained in advance and tabulated as described later, and the value of n is obtained by referring to this. . Next, the pop instruction is executed n times to extract all arguments of this function from the stack area.

  In this way, the function logging routine can obtain function call information at the function caller before jumping to this. The function logging routine acquires this function call information, stores it in the log buffer area of the memory, and further updates the storage destination address.

  By such processing, it is possible to log the function sequence in the calling order. This function may be a nested function.

  When a C language source program is compiled and the obtained object programs are linked, a symbol table including information in which a function name defined in C language is associated with an address of the function is obtained.

  FIG. 6 shows a function information table including the function name extracted from the symbol table and its entry address, the number of words n of all arguments of the function, and the address (exit address) of the return instruction in this function. . In the function logging routine, the value of the argument is obtained by referring to this table, and the function name and the function call information including the argument are described as shown in FIG. Although the number of bytes of each argument is not necessarily the same, in the present embodiment, the number of bytes is the same for the sake of simplicity. The obtained argument string delimiter may be changed to the actual delimiter at the time of analysis.

  Note that the type and number of bytes of each argument may be obtained by referring to the symbol table or from the source code and stored in the function information table, and the function call information may be the same as the description format in the source code. .

  The return instruction address may be configured to detect the return instruction ret while incrementing the subroutine address in FIG. 6 and determine the address as the return instruction address of the subroutine. In this case, if the address of the subroutine to be traced is known, the trace function can be added to the image forming apparatus 10 with the same program regardless of the type of the image forming apparatus 10.

  FIG. 1 is a functional block diagram relating to the debug function of the image forming apparatus.

  In FIG. 1, blocks 30 to 34 and 14 are existing configurations in the image forming apparatus 10, and a tracer 40 is added thereto.

  The application program 30 is a machine language program to be traced, and is all or a part of a program that causes the image forming apparatus 10 to function as a multifunction peripheral. The peripheral device 31 is a hardware configuration of the scanner 15 and the printer 16 in FIG. 8 and is controlled by the controller 32. The controller 32 includes a one-chip microcomputer for controlling the scanner 15 and a one-chip microcomputer for controlling the printer 16. The communication unit 33 of the application program 30 causes the MPU 11 to communicate with the one-chip microcomputer by a subroutine constituting the application program 30, and causes the controller 32 to send a control command (request) such as a scan command, a paper feed command, and a bit. Transmits map data transmission start command, post-processing command, and the like, and also the status of the peripheral device 31 from the controller 32, for example, whether or not there is paper in each paper feed stage, scanner status, paper jam error, etc. The open / close state and switch operation state of each cover are acquired. These requests and states are made via the OS and communication buffer 34. That is, the communication unit 33 requests communication from the OS, and acquires the status data received by the communication buffer 34 via the OS. The communication buffer 34 is a part of the shared area in the DRAM 13D.

  Status notifications such as errors and cover opening / closing changes from the controller 32 are processed in the interrupt routine, but processing in the communication unit 33 is also required from other routines, so the subroutine from the interrupt routine to the communication unit 33 is processed. Is called.

  Next, the tracer 40 will be described.

  The tracer 40 has a software configuration for the MPU 11 (including a log buffer). When an unknown error occurs, the tracer 40 is temporarily stored in the DRAM 13D by a user operation as will be described later. The

  The tracer 40 includes blocks 41 to 52, of which the log buffer 43, the buffer pointer 44, the log buffer 47, and the buffer pointer 48 are configured in a shared data area in the DRAM 13D.

  The replacement unit 41 includes a normal replacement unit and a reverse replacement unit. The normal replacement unit includes the return instruction ret stored in this address with respect to the address of each return instruction ret included in the function information table of FIG. Is replaced with the unconditional jump instruction jmp fncLogging to the function logging routine as described above. However, for the address of the return instruction ret of the function constituting the communication unit 33, the return instruction ret stored at this address is replaced with an unconditional jump instruction jmp commlogging to the communication logging routine described later.

  FIG. 5 is a schematic explanatory diagram of the assembly language program after replacement by the replacement unit 41 of FIG. In this figure, “interrupt” is an interrupt routine executed in response to reception from the controller 32, and a subroutine “com” of the communication unit 33 is called by this interrupt routine. The subroutine “com” is also called from the “main” routine.

  The reverse replacement unit performs reverse replacement with the normal replacement unit, and returns the application program 30 to the original state.

  The logging unit 42 includes the function logging routine. When the application program 30 is started after the normal replacement process in the replacement unit 41 is completed, each time the logging target function represented by the symbol in the function information table in FIG. 6 is called, the function jumps to the logging routine.

  The logging unit 42 acquires the function call information of the function call source as described above, and stores it in the log buffer 43. The log buffer 43 is a loop buffer (an endless buffer that returns from the upper limit address of the range to the lower limit address) in which valid data is stored from the read address to the write address −1, and is a FIFO buffer that includes a read pointer 440. And a buffer pointer 44 including a write pointer 441. That is, the logging unit 42 starts writing the information from the address indicated by the write pointer 441 and updates the content of the write pointer 441 to the next write address.

  The log collection unit 45 is activated each time writing to the log buffer 43 is completed, and obtains the usage rate of the log buffer 43 from the contents of the buffer pointer 44. When this is 90% or more, for example, or the image forming apparatus 10 In the ready state, the contents of the log buffer 43 are saved as a log file in the hard disk 14 with reference to the buffer pointer 44, and the contents of the read pointer 440 are updated.

  On the other hand, the communication logging unit 46 stores the communication data newly written in the communication buffer 34 in the log buffer 47 in the same manner as the logging unit 42 for each jump from the communication unit 33 by the above-described replacement. The communication data may be any data written in the communication buffer 34, and may be only received data. This is because the received data includes data corresponding to transmission data (request) and data unilaterally supplied from the controller 32 as in an error state. The buffer pointer 48 is used and updated by the communication logging unit 46 and the log collection unit 45 in the same manner as the buffer pointer 44. The log collection unit 45 performs the same processing on the log buffer 47 as the processing on the log buffer 43.

  When the communication logging unit 46 stores communication data in the log buffer 47, the communication logging unit 46 stores a communication ID (serial number) for identifying this data in association with the communication data, and then sets a notification flag F in the shared area of the memory. By setting, the logging unit 42 is notified that new communication data has been stored. FIG. 7B is an explanatory diagram of a communication log, and “com01” and the like are communication IDs. If the notification flag F is “1”, the logging unit 42 stores an unstored communication ID in the log buffer 43, and then stores function call information in the log buffer 43.

  The data compression unit 49 compresses log data stored in the hard disk 14. This compression includes compression by expressing the repetition of the same function using the same argument by the number of repetitions, and normal compression. For example, when fnc1 (10, 18) is repeated 50 times, the former is compressed by expressing it as fnc1 (10, 18) × 50. The same applies to the repetition in units of function sequences.

  The encryption unit 50 encrypts the compressed data. This is to prevent leakage of secret information related to the structure and operation of the program by analyzing the log data.

  The log transmission unit 51 transmits the compressed and encrypted log data to a predetermined address by e-mail.

  The user interface unit 52 activates the primary replacement unit of the replacement unit 41 or the data compression unit 49 in response to a command from the host computer 20.

  FIG. 2 is a detailed flowchart showing the operation of the logging unit 42. Hereinafter, the parenthesized characters are step identification codes in FIG.

  (S0 to S2) If the notification flag F is set, the new communication ID in the log buffer 47 is stored in the log buffer 43 together with the line feed code, and the notification flag F is reset.

  (S3) The pop instruction is executed to obtain the return address from the register eax or from the link register lr.

  (S4) If the subroutine call instruction “call” is, for example, 4 bytes, 4 is subtracted from this return address to obtain the address of the subroutine call source.

  (S5) The branch destination address that is the operand of the subroutine call instruction “call” at the address is obtained, and the function name and argument acquisition pop instruction repetition number n corresponding to this address are obtained by referring to the function information table.

  (S6) The function name with “(” added is stored in the log buffer 43, and the write pointer 441 is updated.

  (S7) -4n is added to the stack pointer. However, it is assumed that 1 word = 4 bytes of data moves in each of the push instruction and the pop instruction.

  Thereafter, the process between S8 and S11 is repeated n times.

  (S9) Pop from the stack area to the register eax.

  (S10) The actual argument (eax) is stored in the log buffer 43 together with the delimiters “,” and the write pointer 441 is updated. Here, (eax) means the contents of the register eax.

  (S12) The delimiter symbol “,” stored last in the log buffer 43 is replaced with a closing parenthesis “)” + line feed code, and the write pointer 441 is updated.

  By such processing, function names including arguments described in C language can be sequentially stored in the log buffer every time the function is executed.

  Next, a method of using the tracer 40 configured as described above will be described.

  The program for the tracer 40 and the program for installing the program in the DRAM 13D of the image forming apparatus 10 via the NIC 18 are compressed together and stored in the external storage device of the Web server of the image forming apparatus manufacturer. Can be downloaded. The program of the tracer 40 includes the above-described transmission destination address used by the log transmission unit 42. This address is, for example, the e-mail address of the person in charge of error analysis at the manufacturer.

  When an unknown error occurs in the image forming apparatus, the user resets the image forming apparatus 10 to return to the initial state, operates the host computer 20 to download the program from the Web page, and decompresses the program. Then, the installation program is started and the program of the tracer 40 is stored in the DRAM 13D via the NIC 18.

  The user operates the host computer 20 to activate the normal replacement unit of the replacement unit 41 via the user interface unit 52. After the replacement is completed, the user operates the operation panel 19 so as to satisfy the same conditions as when the error has occurred. As a result, the function log is stored in the hard disk 14 together with the peripheral device log.

  When the error is reproduced, the user operates the host computer 20 to activate the data compression unit 49 via the user interface unit 52. As a result, the log data is compressed and further encrypted, and the data is transmitted to the address by e-mail.

  Next, the reverse replacement unit of the replacement unit 41 is activated, and the application program 30 returns to the original state. The user resets the image forming apparatus 10 to return to the initial state. As a result, the tracer 40 is erased from the DRAM 13D, that is, the image forming apparatus 10 is in the original state.

  The person in charge of error analysis decrypts the received data, decompresses it, and investigates the cause of the error. At this time, for example, the log data is used by a debugger to reproduce the operation leading to the error.

  According to the first embodiment, the communication unit 33 communicates with a controller that controls peripheral devices such as the scanner 15 and the printer 16 included in the image forming apparatus 10 and stores the received peripheral device state in the memory buffer. Is included in the machine language program (application program) 30 of the image forming apparatus 10, and the program of the replacement unit 41 sends a return instruction from the subroutine of the communication unit 33 to the processor 11 of the image forming apparatus 10. , The word length is replaced with a jump instruction to the program of the communication logging unit 46 whose length is equal to or less than the return instruction, and the content stored in the memory buffer is transmitted to the processor 11 of the image forming apparatus 10 as communication information. Based on the write pointer 481, it is stored in the DRAM 13D, and the write pointer Since the contents of 81 are updated to the address to be stored next, and the instruction pointer of the processor 11 is changed to the return address by executing the return instruction, the image forming apparatus 10 that does not have the tracing function has a tracing function of peripheral device operation. It can be easily added, and this brings about an effect that the error analysis time can be shortened.

  If no error occurs, there is no need to add a trace function, so that the normal operation is not delayed and the program size can be prevented from increasing.

  Furthermore, there is an effect that it is not necessary to provide the image forming apparatus 10 with a special circuit for tracing.

  In addition, the program of the replacement unit 41 gives the processor 11 of the image forming apparatus 10 a return instruction from a subroutine other than the subroutine constituting the communication unit 33 included in the machine language program 30, and the word length is equal to or less than the return instruction. , The program 11 of the logging unit 42 replaces the processor 11 of the image forming apparatus 10 with the jump instruction to the program of the logging unit 42, and the return address from the subroutine including the jump instruction replaced by the program of the replacement unit 41. Information about the subroutine call instruction stored immediately before the return address is stored in the DRAM 13D based on the write pointer 441, the contents of the write pointer 441 are updated to the address to be stored next, and the return instruction The instruction poi of the processor 11 by execution Since the data is changed to the return address, a trace function for each subroutine can be added to the image forming apparatus 10 in association with the trace function for peripheral device operation, thereby further reducing the error analysis time. There is an effect that it becomes possible.

  Further, since the program of the replacement unit 41 causes the processor 11 of the image forming apparatus 10 to replace the return instruction at the address included in the function information table of FIG. 6 with a jump instruction, only the functions that need to be traced can be traced. There is an effect that it becomes possible.

  Further, the program of the communication logging unit 42 adds the communication ID to the communication information to the processor 11 of the image forming apparatus 10 and stores it in the log buffer 47, and the program of the logging unit 42 transmits to the processor 11 of the image forming apparatus 10. When the communication flag F indicates that a communication ID has been newly added to the log buffer 47, this log ID is added to the information related to the subroutine call instruction before writing the function log. Therefore, it is possible to associate and combine both logs while avoiding complications, and even if an interrupt that indirectly calls a subroutine of the communication unit 33 is accepted, a communication log is taken while the subroutine log is being acquired. The effect that can be avoided.

  Furthermore, the machine language program 30 is generated by compiling a source program in a high-level language such as C language, and the function name in the source program corresponding to the subroutine in the machine language program 30 corresponds to this. A function information table having a machine language subroutine address as a field, and the program of the logging unit 42 further causes the processor 11 of the image forming apparatus 10 to refer to the function information table and use the operand of the machine language subroutine call instruction. Since the function name corresponding to a certain branch destination address is acquired as a part of the information related to the subroutine call instruction, an error analysis is facilitated.

  Also, the reverse replacement program of the replacement unit 41 causes the processor 11 of the image forming apparatus 10 to replace the jump instructions to the logging units 42 and 46 with return instructions from the subroutines, so that the reverse replacement program is executed after tracing. As a result, even after tracing, the normal operation is not delayed and the program size can be prevented from increasing.

  Note that the present invention includes various other modifications.

  For example, instead of the function name shown in FIG. 6, a log of a subroutine call code including the address or operand may be taken and converted into a function name by a program on the error analyst side. In addition, since the log is taken by one processor 11, the interrupt in the communication unit 33 is prevented from occurring during the processing in the logging unit 42 (with an interrupt mask), and the log buffer 43 and the log buffer 47. In this case, the configuration of the trace function is simplified. Furthermore, since only the log of the function name string is effective for error analysis, a configuration may be adopted in which no log is taken up to the function argument.

  Also, the same program as the application program 30 is loaded on the host computer 20 and the host computer 20 performs the above replacement, or the manufacturer has a replacement and the user downloads it from the web page. Then, this may be configured to be stored in the image forming apparatus 10.

  Further, the program of the tracer 40 may be stored in advance in a removable storage device such as the memory 13R, 13N, HDD 14 or USB memory, and the trace function may be added only when necessary in the same manner as described above.

It is a functional block diagram regarding the trace function of the image forming apparatus. It is a detailed flowchart which shows operation | movement of the logging part in FIG. (A) is explanatory drawing which shows the relationship between the main routine described in C language, and a subroutine (function), (B) is explanatory drawing which added the function logging routine fncLogging further. It is explanatory drawing of what described the machine language program corresponding to FIG. 3 (B) by the mnemonic. It is a schematic explanatory drawing of the assembly language program after the replacement by the replacement part of FIG. It is a figure which shows the function information table containing the function name extracted from the symbol table, its address, the word number n of all the arguments of the function, and the address of the return instruction in this function. (A) is explanatory drawing of the function log obtained with the tracer of FIG. 1, (B) is explanatory drawing of the communication log obtained with this tracer. FIG. 2 is a schematic block diagram illustrating a hardware configuration of the image forming apparatus.

Explanation of symbols

10 Image forming apparatus 11 MPU
12 interface 13R ROM
13N NVRAM
13D DRAM
14 Hard disk 15 Scanner 16 Printer 17 Modem 18 NIC
19 Operation Panel 20 Host Computer 30 Application Program 31 Peripheral Device 32 Controller 33 Communication Unit 34 Communication Buffer 40 Tracer 41 Replacement Unit 42 Logging Unit 43, 47 Log Buffer 44, 48 Buffer Pointer 440, 480 Read Pointer 441, 481 Write Pointer 45 Log Collection unit 46 Communication logging unit 49 Data compression unit 50 Encryption unit 51 Log transmission unit 52 User interface unit

Claims (10)

A tracing function addition program for an image forming apparatus that adds a tracing function to a machine language program stored in a storage unit of the image forming apparatus, and includes a first replacement program and a first logging program stored in the storage unit. The machine language program has a communication subroutine for communicating with a controller that controls peripheral devices included in the image forming apparatus and storing the received peripheral device status in a memory buffer.
The first replacement program causes the processor of the image forming apparatus or another processor to replace a return instruction from the communication subroutine with a jump instruction to the first logging program whose word length is less than or equal to the return instruction. Features
The first logging program is sent to the processor of the image forming apparatus.
The content stored in the memory buffer is stored as communication information in the storage means based on the first write pointer, the content of the first write pointer is updated to the address to be stored next,
Changing the instruction pointer of the processor to the return address;
A tracing function addition program for an image forming apparatus, comprising a step. A second replacement program and a second logging program stored in the storage means;
The second replacement program sends a return instruction from a subroutine other than the communication subroutine included in the machine language program to the processor of the image forming apparatus or another processor, and the second instruction having a word length equal to or less than the return instruction. 2 It is replaced with a jump instruction to the logging program,
The second logging program is sent to the processor of the image forming apparatus.
Obtaining a return address from a subroutine including a jump instruction replaced by the second replacement program;
Information related to the subroutine call instruction stored immediately before the return address is stored in the storage means based on the second write pointer, and the content of the second write pointer is updated to the address to be stored next,
Changing the instruction pointer of the processor to the return address;
2. The trace function addition program for an image forming apparatus according to claim 1, further comprising a step of obtaining time-series information of a combination of the device communication information and information on the subroutine call instruction. Further including address data in which an address of a return instruction from the communication subroutine and a return instruction from a subroutine other than the communication subroutine are described;
Both the first and second replacement programs cause the processor of the image forming apparatus or the other processor to replace the return instruction of the address included in the address data with the jump instruction.
The trace function addition program for an image forming apparatus according to claim 2, wherein: The first logging program further causes the processor of the image forming apparatus to add a communication ID to the communication information and store it in the storage means,
The second logging program further causes the processor of the image forming apparatus to add the communication ID to information related to the subroutine call instruction when the communication ID is newly added to the storage means. Stored in the means,
4. The tracing function addition program for an image forming apparatus according to claim 1, wherein the tracing function addition program is for an image forming apparatus. The second write pointer is identical to the first write pointer;
The second logging program further prohibits the processor of the image forming apparatus from interrupting the first logging program during execution thereof.
4. The tracing function addition program for an image forming apparatus according to claim 1, wherein the tracing function addition program is for an image forming apparatus. The machine language program is generated by compiling a high-level language source program,
A function information table in which a function name in the source program corresponding to a subroutine in the machine language program is associated with an address of the subroutine;
The second logging program further causes the processor of the image forming apparatus to refer to the function information table so that a function name corresponding to a branch destination address that is an operand of the subroutine call instruction is obtained. As part or all of
6. The tracing function addition program for an image forming apparatus according to claim 1, wherein the tracing function addition program is for an image forming apparatus. A reverse replacement program stored in the storage unit of the image forming apparatus;
The reverse replacement program causes the processor of the image forming apparatus to replace a jump instruction to the first logging program and a jump instruction to the second logging program, respectively, with a return instruction from a subroutine.
7. The tracing function addition program for an image forming apparatus according to claim 1, wherein the tracing function addition program is for an image forming apparatus. A processor;
Storage means coupled to the processor for storing the first and second replacement programs, the first and second logging programs and the reverse replacement program according to claim 7;
The trace function can be added only when an error occurs by executing the first and second replacement programs, the first and second logging programs, and the reverse replacement program in this order. An image forming apparatus. An image forming apparatus trace function adding method for adding a trace function to a machine language program stored in a storage unit of an image forming apparatus, using a first replacement program and a first logging program stored in the storage unit The machine language program has a communication subroutine for communicating with a controller for controlling peripheral devices included in the image forming apparatus and storing the received peripheral device status in a memory buffer.
The first replacement program causes the processor of the image forming apparatus or another processor to replace the return instruction from the communication subroutine with a jump instruction to the first logging program whose word length is equal to or less than the return instruction.
With respect to the processor of the image forming apparatus by the first logging program,
The content stored in the memory buffer is stored as communication information in the storage means based on the first write pointer, the content of the first write pointer is updated to the address to be stored next,
Changing the instruction pointer of the processor to the return address;
And a tracing function adding method for an image forming apparatus. Further using a second replacement program and a second logging program stored in the storage means,
A return instruction from a subroutine other than the communication subroutine included in the machine language program is sent to the processor of the image forming apparatus or another processor by the second replacement program, and the word length is less than or equal to the return instruction. 2 Replace with a jump instruction to the logging program,
With respect to the processor of the image forming apparatus by the second logging program,
Obtaining a return address from a subroutine including a jump instruction replaced by the second replacement program;
Information related to the subroutine call instruction stored immediately before the return address is stored in the storage means based on the second write pointer, and the content of the second write pointer is updated to the address to be stored next,
Change the instruction pointer of the processor to the return address;
10. The trace function adding method for an image forming apparatus according to claim 9, wherein time series information of a combination of the device communication information and information on the subroutine call instruction is obtained.