JP2002297402A - Digital device, task management method and program therefor - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a task management method that prevents the forced termination of a task during the task operation that may cause a system failure. SOLUTION: A program execution means transmits the information on the attribute of a function being executed and concurrently makes an inquiry about the execution of the forced termination of the task belonging to the function. A task execution determination means determines, depending on the attribute of the function being executed, the execution of the forced termination. Moreover, a task attribute recognition means stores, in a task attribute information storing means, the attribute of the function being executed, and sends back, for the inquiry made from the task execution determination means about the attribute of the function, the stored attribute of the function.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a digital device, a task management method and a program therefor, and more particularly, to a digital device for managing forced termination of a task in a multitask operation system, a task management method and a program therefor.

[0002]

2. Description of the Related Art Conventionally, for example, STB (set-top bo
x: General name of a device that provides additional functions by connecting to a home TV, such as a cable TV control box)
In the case of products that realize various functions mainly using software, such as mobile phones and mobile phones, the software is
It is provided in the form of a so-called embedded OS in which an OS (operation system) and a program for realizing each function are stored in advance. Manufacturers that provide products with the embedded OS can sufficiently verify the operation of each function of the embedded OS and debug in various operating states, so that a reliable product that operates stably It is possible to provide.

In recent years, the life time of some products has been short, and the cycle of adding / changing new functions has also become short. For this reason, in order to flexibly respond to the addition or change of the function, the use of a general-purpose OS in place of the embedded OS is increasing. Further network development (diversification) and J
The spread of multifunctional interpreter languages suitable for networks represented by ava (R) has made it easier to download programs as functions are added or changed. This is a factor.

An execution form of a general task when the general-purpose OS is used will be described below. Since the general-purpose OS as described above normally operates as a multitask, the description including the multitask will be described.

[0005] In the multitask OS, as shown in FIG.
(502, 503) are executed. The above process 1
Under the management of (502), for example, thread 1 (5
04), thread 2 (505), and process 2 (50
Under the management of 3), a plurality of threads are executed, for example, a thread 4 (506). For example, when the process 1 (502) is executed, resources such as a memory space and an I / O (Input / Output) space are allocated by the OS 501 at the time of execution, and the resources are allocated to the thread 1 (504) and the thread 2 (thread 2). Shared at (505).

Here, the above process refers to one execution unit of a program. That is, while independently possessing the resources and the like, at the time of switching (when switching the process by the multitask OS), all the contents of the CPU registers are saved, and then the register values for the process of switching the control are loaded. Is a unit that guarantees the independence of each execution unit. The thread is also one execution unit of the program, and enables multitask processing in the same process. The unit of the process or the thread is handled differently depending on the OS, but is essentially an execution unit of the program, and can be called a set of functions. For this reason, the process and the thread will be described separately as appropriate, but both are tasks and one execution unit of the program. In addition, applications are a broad task.

Next, the structure of the above-described task (process and thread) will be briefly described. The task is generally constituted by a set of functions.For example, a predetermined function passes an argument to another function, and the another function returns a return value calculated using the argument to the predetermined function again. Hand over,
The predetermined function is executed in such a procedure that the subsequent processing is executed using the return value. For example, referring to FIG. 6, a task (thread 1) 601 sets an application function a (602) developed by a user as a main routine (main function), and executes an application function b (603) in the course of processing of the main routine. ) Is calling. The application function b (603) is
Further, a system library function a (604) provided as a system library function is read as needed, and the system library function a (604) calls an application function c (605).
Each of the functions called in the above process returns a return value calculated using the argument given at the time of the call,
The called function executes the following processing accordingly.

As described above, the processing of a predetermined task (main routine) is completed by processing a plurality of functions constituting the task. Here, the application function is, for example, a function created by a person who has programmed the task as needed, and the system library function is a basic function or the like provided in advance. Note that both the application function and the system library function are composed of, for example, tens to thousands of steps (instructions).

Now, each of the above-mentioned threads 1 (504) and 2 (505) is, as shown in FIG.
The processing is executed in the processing time sequentially allocated by the OS 501. That is, the OS 501 assigns the processing times 507 to 5 to the thread 1 and the thread 2 (here, the processing of the thread 3 is not considered) in the timer processing.
Give 10 Here, for example, first, the processing time 507
Is allocated by the OS 501, the thread 1 is executed, and during the processing time 508 which is subsequently allocated, the thread 2 is executed. In this way, the OS sequentially gives processing time to a plurality of threads (tasks), so that a plurality of processes can be executed in parallel, that is, a multitask OS can be realized. The switching of the thread (task) is called dispatch.

The use of the general-purpose OS described above, and the development (diversification) of networks and the spread of multifunctional interpreter languages, make it possible to flexibly add new functions to various products. ing.

After the system is changed by adding a new function or the like, various usage forms combining the new function are conceivable. In such a state, resources are generally consumed in large amounts, and resources cannot be allocated to a program to be executed later, so that a new program cannot be started. Conventionally, in order to avoid such a state, the above tasks (processes and threads)
Can issue, for example, an instruction to end the processing of another task, that is, a forced termination instruction. With the forced termination instruction, it is possible to release resources of a different task and start a new program. Insufficient resources often occur in products with limited functions (for example, STBs and mobile phones) that do not have sufficient resources, unlike general-purpose personal computers.

However, if the processing of another task can be forcibly terminated unnecessarily, it is conceivable that the task is terminated while important processing such as data writing is being performed. For this reason, Japanese Unexamined Patent Application Publication No. 10-693
In the technique described in Japanese Patent Application Publication No. 92-92, a forced termination prohibition section (abort prohibition section) can be set for a predetermined processing section to prohibit forced termination in the processing section.

Referring to FIG. 7, a description will be given of a mechanism for issuing an instruction for terminating the processing of a task and setting of a forced termination prohibition section.

In FIG. 7, it is assumed that a thread 1 (601) and a thread 2 (701) are activated as independent tasks on the OS. The thread 1 (6
01) and the thread 2 (701) are executing the processing while being switched at any time in the above-described multitask processing. For example, when the processing time assigned to the thread 1 (601) ends, the thread 2 (701) 701) operates.

Here, when the processing is switched to the thread 2 (701) at the time of execution 702 of the system library function a (604) in the thread 1 (601),
The thread 2 (701) is, for example, an application function d
The processing is executed from (703).

Subsequently, at a predetermined point 705 of the processing of the application function e (704) in the thread 2 (701), the thread 2 (701)
01), a thread 1 is issued at a predetermined point 706 of the application function d (703).
It is assumed that the processing has been switched to (601). In this case, for example, when executing the system library function a (604) in the thread 1 (601), a forced termination instruction is received, and the system library function a (6) is received.
04) Thread 1 during execution (immediately after execution 702)
(601) is forcibly terminated by the OS, for example. Note that if the processing by each of the functions (602 to 605) is forcibly terminated, the entire processing is significantly affected, and the following forced termination prohibition sections are provided.

That is, a predetermined point 707 of the application function a (602) in the thread 1 (601)
, The application function a (602) issues a forced termination prohibition instruction 708. The forced termination prohibition command is recognized and stored in a predetermined process in the OS, for example. Next, as described above, when a forced termination instruction is issued from the thread 2 (701) at a predetermined point 705 and the process is switched to the thread 1 (601), for example,
S determines whether or not the above-mentioned forced termination prohibition command has been issued. Here, since the forced termination prohibition command has been issued, normal processing is continued without forcibly terminating.

Subsequently, an application function a (602)
At a predetermined point 709, a forced termination permission instruction 710
Is issued, the forced termination permission instruction is recognized by, for example, predetermined processing in the OS, and the forced termination prohibition instruction 708 is issued.
The section from the time of issuance to the time of issuance of the forced termination permission instruction 710, that is, the forced termination prohibition section ends.

When the forced termination prohibition section ends, for example, the OS starts the thread 2 at the predetermined point 705.
The thread 1 (601) is forcibly terminated at a predetermined point 709 in the application function a (602), reflecting the forced termination instruction issued by (701).

As described above, by issuing a forced termination instruction between tasks (between threads), for example, it is possible to release resources used by other tasks.
In addition, when an important process that affects the system (for example, an operation on a shared resource) is being performed, forced termination by another task is prohibited, so that the important process can be normally terminated. .

[0021]

However, when the above-mentioned prior art is used, the following problems occur. That is, as described above, when a program (software) having a new function is downloaded to a general-purpose OS using a network and executed, for example, unlike the embedded OS,
It is conceivable that the user environment does not operate properly due to a wide variety of user environments, such as execution of a plurality of different programs by each device. In such a case, it is necessary to forcibly terminate the program. However, if the forcible termination prohibition section is set, a problem occurs that the program cannot be forcibly terminated.

In particular, when a program created by a third party is downloaded via the Internet, the program is not always created based on good intentions. Is accompanied.

That is, for example, the thread 1 (6) shown in FIG.
01) is a malicious program. Specifically, for example, an infinite loop is performed within the application function b (603), and a similar application function b (6) is executed.
03) can be considered as a program that generates a thread. In such a case, if the malicious program is executed, the threads multiply, and the forced termination instruction for the thread is invalidated by the setting of the forced termination prohibited section described above. In this case, the terminal (product) that has executed the above-mentioned program loses control of the OS, and eventually needs to turn off the power.

Such a phenomenon is conceivable not only in a product that provides a specific function using a general-purpose OS but also in a general-purpose OS such as Windows (R) or UNIX (R).

Therefore, the present invention has been proposed based on the above-mentioned conventional circumstances, and is a task that may cause a failure in the system, for example, a task that does not forcibly terminate the task while operating a shared resource. The purpose is to provide a management method.

[0026]

The present invention employs the following means to achieve the above object. That is, the present invention is premised on a digital device having an operating system that executes a plurality of tasks managed as one execution unit in parallel by program execution means. Here, the program execution means transmits information on the attribute of the function being executed to the task attribute recognition means,
The task execution determination means is inquired about the forced termination of the task to which the function belongs. Further, the task execution determining means determines the execution of the forced termination based on at least the attribute of the function being executed in response to the inquiry about the execution of the forced termination. Further, the task attribute recognizing means stores the attribute of the function being executed in the task attribute information storing means based on the information on the attribute of the function transmitted from the program executing means, and outputs the information from the task execution determining means. In response to the inquiry about the attribute of the function being executed, the attribute of the function stored in the task attribute information storage unit is returned.

In the above configuration, the task notifies the task attribute recognizing unit of the type of the function to be executed subsequently when the function is called and when the process returns, so that the task attribute information storing unit stores the currently executed function. The type of the task being performed is always stored, so that the attribute information of the function executed in the current task stored in the task attribute information storage unit can be referred to and determined. Therefore, even in the forced termination prohibition section, when the predetermined function is executed,
It is possible to flexibly control the forced termination such that the task can be forcibly terminated, while the task is not forcibly terminated when another function that may cause a failure in the system is executed.

There is also a configuration in which the information on the attribute of the function is set as the name of the executed function, and the task attribute recognizing means determines the attribute of the executed function based on the name.

In this configuration, depending on the language, it may be difficult to determine the attribute of the function based on the specification of the language and to directly notify the task attribute recognizing means. You can check the attributes of the function.

The task, which is one execution unit, may be a process or a thread.

Further, the task attribute information storage means stores the attribute of the task itself in place of the attribute of the function constituting the task, thereby enabling control of forced termination based on the attribute of the task.

Incidentally, the program and the program recording medium are configured to realize the functions of the above-mentioned respective means on a computer.

[0033]

Embodiments of the present invention will be described below with reference to the accompanying drawings to provide an understanding of the present invention.
It should be noted that the following embodiments are examples embodying the present invention, and do not limit the technical scope of the present invention.

[Embodiment 1] A digital apparatus 100 according to Embodiment 1 of the present invention will be described with reference to FIGS. Here, the digital device 100 is, for example, an STB, a mobile phone, a home appliance, a personal computer, or the like, and adds (changes) or modifies a predetermined function by adding (adding) an external application (program). Indicates a device that is capable of

First, the digital device 100 acquires a predetermined application (program: 102) via a network 101 such as the Internet, for example, and stores it in the storage unit 103. Here, the application 102 is, for example, a program described in an interpreter language for adding a new function to the digital device 100. When the application 102 is executed, the task 201 shown in FIG.
Is generated and the process is executed. Note that the acquisition of the application 102 is not necessarily performed by the network 10.
1, and may be obtained via a storage medium such as a memory card.

Next, when the application 102 is executed, a RAM (Random Acc.
(Sess Memory) or the like (FIG. 4: S401). The application 102
As shown in task 201 in FIG. 2, application function a (203) and application function b (20)
4), composed of an application function c (206). Further, since the application 102 calls the system library function a (205), which is a system library function at the time of execution, for example, when read by the loader, the application 102 simultaneously reads from the system library 104 stored in the storage unit 103. , The system library function 107 is read out to the temporary storage means 105.

Subsequently, when the application function a (203), which is the main function of the application 102, is read by the program execution means 108, the OS 130
Generates the task 201 corresponding to the application function a (203) and allocates resources to the task (FIG. 4: S402). Thereafter, the application 102 is managed as a task 201.

Further, when the task is generated, the OS 1
Reference numeral 30 denotes a task state storage unit 110, a forced termination information storage unit 114, and a task attribute information storage unit 11, which will be described later.
7, a task flag 118 corresponding to the task 201 is created, and for example, “0” is stored in the created flag area (FIG. 4: S403). Further, for example, the program executing means sends the current task 2 to the task attribute recognizing means 116.
01 is notified that the function being executed is an application function (FIG. 4: S404). Task 20
1 receives the notification that the function being executed is an application function,
6 stores, for example, “1” indicating that the application function is being executed in the task flag 118 corresponding to the task 201 in the task attribute information storage unit 117.
Here, for example, when a task is created by an application provided by the OS, since the main function is usually a system library function, the task flag 1 corresponding to the task 201 of the task attribute information storage unit 117
"0" is stored in "18".

Thereafter, the task 201 is sequentially executed from the first command (instruction) of the application function a (203). Also, if necessary, the application function b
Other functions such as (204) are read by the program execution means 108. When one of the above commands is executed, for example, an inquiry is made to the task execution determining unit 111 as to whether or not a forced termination instruction has been transmitted to the task (in this case, the task 201), which will be described in detail later.

The processing performed when the new application is executed (initial processing 400 in FIG. 4) has been described above. Note that, for the sake of understanding, the program execution means 1
At 08, the task 202 including the application function d (208) and the application function e (209) is also executed.

Next, the details of the processing of the task state setting means 109 when the function being executed in the task issues the forced termination prohibition instruction will be described.

For example, the application function a (20
At a predetermined point 213 during the processing of 3), the task 20
When the forced termination prohibition command 214 is transmitted from 1 to the OS 130, the task status setting unit 109 receives the forced termination prohibition command 214. The task status setting unit 109 that has received the forced termination prohibition command 214 stores, for example, “1” in the flag area 121 corresponding to the task 201 in the task status storage unit 110. “1” stored in the flag area 121 means that the task 201 is currently in the forced termination prohibited section (forced termination is prohibited).

Also, for example, the application function a (20
At a predetermined point 215 during the processing of 3), the task 20
When the forced termination permission command 216 is transmitted from 1 to the OS 130, the task status setting unit 109 receives the forced termination permission command 216. The task state setting unit 109 that has received the forced termination permission instruction 216 stores, for example, “0” in the flag area 121 corresponding to the task 201 in the task state storage unit 110. “0” stored in the flag area 121 means that the currently executed task 201 is not currently in the forced termination prohibition section (not forced termination prohibition).

As described above, the task state storage means 110
Indicates that the status of each task is forcibly terminated (flag "1")
Or whether the forced termination is possible (flag “0”) is always stored. Thereafter, for example, when the task execution determining unit 111 inquires about the contents of each task flag in the task state storage unit 110, the task state setting unit 109 reads out the value stored in the task flag and executes the task execution determining unit. Reply to 111.

Next, the details of the processing of the task attribute recognizing means 116 when the function being executed in the task changes will be described.

The application function a (203) calls, for example, the application function b (204), and the processing in the task 201 is the application function b (204).
When the mode is switched to (204), the task 201 notifies the task attribute recognizing means 116 that the function currently executed in the task 201 is an application function. Here, the task attribute recognition means 116
Stores “1” in the flag area 119 corresponding to the task 201.

When the application function b (204) calls the system library function a (205), the task 201 notifies the task attribute recognizing means 116. In this case, the task 201 executes the task. Since this function is a system library function, "0" is stored in the flag area 119. As described above, when the system library function a (205) calls the application function c (206), "1" is stored in the flag area 119.

When the processing of the application function c (206) is completed and the processing returns to the system library function a (205), similarly to the above-mentioned call, the function to be executed thereafter (processing returns). After this function: the flag “0” or “1” corresponding to “0”) is stored in the flag area 119.

As described above, when the function is called and when the process returns, the task notifies the task attribute recognizing means of the type of the function to be executed thereafter, so that the task attribute information storage means stores the currently executed function in the task attribute information storing means. The type of task being performed is always stored. Thereafter, for example, when the task execution determining unit 111 inquires about the contents of each task flag in the task attribute information storage unit 117, the task attribute recognizing unit 116 reads out the value stored in the task flag and performs the task execution determination. Reply to the means 111.

Now, the program execution means 108
, The tasks 201 and 202 are being executed as described above. Here, task 2
02 is a forced termination instruction 211 for the task 201.
Is a task that issues The timing (point) at which the above-mentioned forced termination instruction 211 is issued depends on OS1
Since the processing differs depending on the task switching timing by the task 30, the detailed processing at each timing will be described later. Here, the details of the processing of the forced termination setting unit 113 when the forced termination instruction 211 is issued will be described. I do.

First, at predetermined points (for example, point 207 shown in FIG. 2),
Assume that the processing has been switched to 2. The task switching is as described in the related art.

Here, when the task 202 issues the forced termination instruction 211 to the task 201, specifically,
For example, a forced termination command 211 issued at a predetermined point 210 by an application function e (209) called by an application function d (208) is received by a forced termination setting unit 113. Upon receiving the forced termination command 211, the forced termination setting unit 113 stores “1” in the flag area 120 of the forced termination information storage unit 114 corresponding to the task 201. “1” stored in the flag area 120 means that the task 201 corresponding to the flag area 120 has received a forced termination instruction. Hereinafter, for example, the task execution determining means 1
When there is an inquiry from 11 about the contents of each task flag in the forced termination information storage means 114, the forced termination setting means 113 reads the value stored in the task flag and returns it to the task execution determination means 111.

As described above, for example, a forced termination command from another task is sent to the forced termination information storage unit 114 via the forced termination setting unit 113 by the flag of the corresponding task (the task receiving the termination command). Is shown.

The above is the processing in the task state setting means 109, the task attribute recognition means 116, and the forced termination setting means 113.

Next, the task state setting means 10 described above
9. Details of the processing performed after the execution of the new application based on the processing of the task attribute recognition means 116 and the forced termination setting means 113 will be described.

After completing the initial processing 400 shown in FIG. 4, the program execution means 108 sequentially executes the first command (instruction) of the application function a (203) of the task 201 (FIG. 4: S405). here,
The program execution means 108 determines that the command is, for example, 1
When the task is executed, the task (here, task 2
In step 01), an inquiry is made to the task execution determination unit 111 provided as a function of the OS 130, for example, as to whether a forced termination instruction has been transmitted. Upon receiving the inquiry, the task execution determination unit 111 inquires the forced termination setting unit 113 about the contents of the task 201 flag (120) of the forced termination information storage unit 114.
The contents of the task flag are as described above.

Here, when the task 201 flag (120) is not "1", if the forcible termination setting means 113 returns, it indicates that the task 201 has not issued the forcible termination command. Execution determination means 11
1 notifies the program execution means 108 of the fact, and the program execution means 108 executes the next command (FIG. 4: S406 No → S405). The next command is, for example, an application function b (203).
In the case where the command is a command for calling, for example, the task 201 flag (119) in the task attribute information storage means 117 is rewritten as needed, as described above.

If the task 201 flag (120) is set to "1" and the forcible termination setting means 113 returns, it indicates that the task 201 has been issued a forced termination command. Execution determination means 1
11 inquires of the task status setting means 109 about the contents of the task 201 flag (121) of the task status storage means 110 (FIG. 4: S406 Yes → S407).

Here, if the task state setting means 109 sends a reply that the task 201 flag (121) is not "1", the task 201 is not in the forced termination prohibition section, that is, the task 201 is terminated. Does not affect the whole system (no operation is performed on the shared resources). Therefore, the task execution determination unit 111 notifies the program execution unit 108 of the fact, so that the program execution unit 10
Reference numeral 8 denotes a function being executed (for example, an application function c (206)) and a function that calls the function (for example, an application function a (203), an application function b (204), and a system library function a (20).
5)) are all ended, and the task 201 is ended (FIG. 4: S407 No → S408 → End).

If the task state setting means 109 returns that the task 201 flag (121) is "1", the task 201 is in a forced termination prohibition section, that is, when the task 201 is terminated. This indicates that there is a possibility of affecting the entire system (for example, an operation is being performed on a shared resource). In this case, the current function execution determining means 112 constituting the task execution determining means 111 further includes
16 is inquired about the contents of the task 201 flag (119) of the task attribute information storage means 117 (FIG. 4:
S407 Yes → S409).

Here, if the task attribute flag (119) is not "1" (it is "0") and the task attribute recognizing means 116 returns, the task 201 executes the current system library function. In other words, the termination of the system library function may affect the entire system (for example, an operation is performed on a shared resource), so the execution of the system library function is forcibly terminated. The process proceeds to the processing of the next command without causing the processing to be performed (FIG. 4: S409 No → S405).

When the task attribute flag (119) is "1", if the task attribute recognizing means 116 returns a response, it means that the task 201 is currently executing an application function. Since there is no possibility (low) of affecting the entire system even if the function is terminated, the function being executed is terminated (FIG. 4: S409 Yes → S410). If the function being executed is the main function, the task 201 is terminated because forcible termination may affect the entire system (FIG. 4: S410 → S405 → E).
nd).

As described above, in the present embodiment,
In addition to the forced termination information stored in the forced termination information storage means (whether or not a forced termination command has been received) and the task status stored in the task status storage means (whether or not the section is a forced termination prohibited section), the task The attribute information (application function or system library function) of the function being executed in the current task stored in the attribute information storage means is referred to and determined. Therefore, even in the forced termination prohibition section, if the application function is being executed, the forced termination (interruption of the application function) can be performed, while the system library function that may cause a failure in the system can be executed. At the time of execution, it is possible to flexibly control forcible termination such as not forcibly terminating the task.

Next, referring to FIG. 3 and FIG. 4, the details of the processing that differs depending on each point receiving the forced termination command will be described. It should be noted that each of the processes represents the flowchart of FIG. 4 in a case-by-case manner and has the same contents as the flowchart.

First, when a forced termination command is received before or after the setting of the forced termination prohibited section of the application function a (forced termination commands 301 and 309), the application function a is terminated, that is, the task 201 is terminated (FIG. 4: S407N).
o → S408).

When a forced termination command is received after setting the forced termination prohibition section when executing the application function a (forced termination commands 302 and 308), the application function a is terminated, that is, the task 201 is terminated (FIG. 4: S407Ye).
s → S409 → S410 → S405 → End).

When a forced termination instruction is received during execution of application function b (forced termination instructions 303 and 307), application function b is terminated and processing returns to application function a, but application function a is also terminated immediately. That is, the task 201 is ended (FIG. 4: S407 Yes → S409 Yes → S410 → S4).
05 twice to End).

The forced termination instruction is sent to the system library function a.
If it is received at the time of execution (the forced termination instruction 304 and (including the forced termination instruction 306)), the system library function a
Without terminating the execution of the application function c. Here, since the application function c is immediately terminated (the case of a forced termination instruction 305 described later), the system library function a is executed again from the point 320 to the point 321 and the process returns to the application function b. The subsequent application function b and application function a immediately end, that is, the task 201 ends (FIG. 4: S407 Yes → S409 No → S405).
→ S406Yes → S407Yes → S409Yes →
S410 (end of application function c) → S405 →
... → 409No → S405 (after the end of system library function a) → S409Yes → S410 (end of application function b) → S405 →... → S41
0 (end of application function a) → to End).

When a forced termination command is received at the time of executing the application function c (forced termination command 305), the application function c is terminated, the process returns to the point 320 of the system library function a, and the process is performed up to the point 321. , The processing returns to the application function b and the application function a, and the processing ends immediately, that is, the task 201 ends (FIG. 4: S407 Yes → S)
409 Yes → S410 (end of application function c) → S405 → ... → S409No → S405 →
... → 409No → S405 (after termination of system library function a) → S409Yes → S410 (termination of application function b) → S405 →... → S410
(End of application function a) → End).

The above is the processing in the first embodiment. However, in the first embodiment, the processing in the case where the forced termination prohibition section can be set has been described, but the determination of the forced termination prohibition section is not necessarily required. That is, it is possible to determine whether or not the forced termination is possible based on only the attribute information of the currently executed function without determining whether or not the section is the forced termination prohibition section. In this case, it is only necessary to exclude the processing of S407 and S408 shown in FIG.

The application function and the system library function have been described as examples of the attributes of the function. However, the present invention is not limited to the above two functions, and further different functions can be classified depending on the language used. In this case, information on the attribute of the different function may be added as a criterion.

[Second Embodiment] Next, in a second embodiment, processing for storing information in a task flag of the task attribute storage means will be described with reference to FIG.

In the first embodiment, the task attribute information storage means is directly notified to the task attribute recognition means 116 of the attribute (application function, system library function) of the function currently being executed by the program execution means 108. The attribute is stored in each task flag 117.

In the second embodiment, when the function currently being executed is changed,
The changed function name (the name of the function to be executed) is transmitted to the task attribute recognizing means 116. Upon receiving the function name, the task attribute recognition unit 116 refers to the application function 106 or the system library function 107 stored in the temporary storage unit 105 to determine whether the function is an application function or a system library function. I do. The task attribute recognizing means 116 that has determined the attribute of the function stores the type of the function in the corresponding task flag.

As described above, even when the function attribute cannot be directly transmitted from the program execution means to the task attribute recognition means 116, the task attribute information storage means stores the attribute of the currently executed function in the corresponding task flag. It becomes possible to do.

In the first and second embodiments, the criterion for executing the forced termination is as follows.
Uses the attributes of the currently executing function in the task. However, it is not always necessary to limit the determination criteria to only the attributes of the function. That is, multitask OS
In, some of the functions of the OS can be executed as independent tasks, which are called system tasks (system processes, system threads, etc.). On the other hand, the task started by the user is an application task (user process, application thread, etc.).

The system task and the application task can be called task attributes. When the two task attributes are compared, the following can be said.

That is, since the system task is provided as a function of the OS, its reliability (security) is high.
On the other hand, the application task may perform malicious processing, and has lower reliability than the system task. Further, while the system task is likely to cause a system failure if terminated, the application task is generally terminated even if the task uses a system library function. In this case, the effect is completed within the application task.

Therefore, in consideration of the above, it can be said that the criterion for the determination can be determined not by the attribute of the function but by the attribute of the task. That is, not the function attribute but the task attribute is stored in the flag area (task flag) stored by the task attribute information storage means. The processing to be stored need only be performed once by the program executing means to the task attribute recognizing means at the time of the initial processing when the task is activated. The stored value is, for example, “0” for a system task and “1” for an application task. Thereafter, the check of the corresponding task flag in the task attribute information storage means is the same.

As described above, the attribute of the task is managed in place of the attribute of the function, and the execution of the forced termination processing for the task is determined, whereby the forced termination can be flexibly controlled.

[0081]

As described above, according to the present invention, when a function is called and when processing returns, the task notifies the task attribute recognizing means of the type of the function to be executed thereafter, and the task attribute is recognized. The information storage means is configured to always store the type of the currently executed task. For this reason, it is possible to refer to and determine the attribute information of the function being executed in the current task stored in the task attribute information storage means, and to execute the predetermined function even in the forced termination prohibition section. If so, it can be forcibly terminated,
On the other hand, when another function that may cause a failure in the system is executed, flexible control of forced termination such as not forcibly terminating the task can be performed.

The task attribute information storage means stores task attributes in place of function attributes, thereby enabling forced termination control based on task attributes.

[Brief description of the drawings]

FIG. 1 is a schematic functional block diagram of a digital device according to the present invention.

FIG. 2 is an image diagram when a forced termination instruction is issued between tasks according to the present invention.

FIG. 3 is a diagram showing points for receiving a forced termination instruction when each function is executed.

FIG. 4 is a flowchart relating to a forced termination instruction process during task execution.

FIG. 5 shows a process, a thread, and an OS according to the related art.
The figure which shows the image of.

FIG. 6 is a diagram showing an example of a function structure in a task.

FIG. 7 is an image diagram when a forced end instruction is issued between tasks in the related art.

[Explanation of symbols]

 REFERENCE SIGNS LIST 100 digital device 101 network 102 application 103 storage means 104 system library 105 temporary storage means 106 application function 107 system library function 108 program execution means 109 task state setting means 110 task state storage means 111 task execution determination means 112 current function execution determination means 113 Forced termination setting means 114 Forced termination information storage means 116 Task attribute recognition means 117 Task attribute information storage means 118 Task flags 119, 120, 121 Flag area 130 OS (OS function)

Continued on the front page F term (reference) 5B098 GA04 GC01 GC14

Claims (14)

[Claims] 1. A task managed as one execution unit,
In a digital device including an operating system that executes a plurality of programs in parallel by a program execution unit, a task attribute information storage unit that stores an attribute of a function constituting the task, and information on an attribute of the function being executed is transmitted. The program execution means for inquiring about execution of a forced termination for the task to which the function belongs; and executing the forced termination based on at least an attribute of the function being executed in response to the inquiry about the execution of the forced termination from the program execution means. Storing the attribute of the function being executed in the task attribute information storage based on the information on the attribute of the function transmitted from the program executing means; To query the attributes of the function being executed from the means A digital device comprising: a task attribute recognizing unit that returns an attribute of the function stored in the task attribute information storing unit. 2. The information on the attribute of the function is the name of the function being executed, and the task attribute recognizing means determines the attribute of the function being executed based on the name. A digital device according to. 3. The digital device according to claim 1, wherein the task managed as one execution unit is a process. 4. The digital device according to claim 1, wherein the task managed as one execution unit is a thread. 5. A task managed as one execution unit,
In a task management method for an operating system that executes a plurality of tasks in parallel, a function that constitutes the task, stores an attribute of the currently executed function, and performs a forced termination of the task to which the executed function belongs. A task management method for determining whether or not the function being executed is forcibly terminated based on the stored attribute of the function. 6. The task management method according to claim 5, wherein the attribute of the function is determined by using a name of the function being executed. 7. The task management method according to claim 5, wherein the task managed as one execution unit is a process. 8. The task management method according to claim 5, wherein the task managed as one execution unit is a thread. 9. Tasks managed as one execution unit are:
The information on the attribute of the function being executed is transmitted to the task attribute recognizing function, and the task execution determining function is inquired about the execution of the forced termination for the task to which the function belongs, to the computer which executes a plurality of programs in parallel by the program executing function. A program execution function; a task execution determination function for determining execution of the forced termination based on at least an attribute of a function being executed in response to an inquiry about the execution of the forced termination; and the function transmitted from the program execution function Based on the information on the attribute of the stored function, the attribute of the function being executed is stored in the storage unit, and in response to the inquiry about the attribute of the function being executed from the task execution determination function,
A program for realizing a task attribute recognition function of returning an attribute of the function stored in the storage means. 10. A computer that executes a plurality of tasks managed as one execution unit in parallel by a program execution function, by transmitting information on an attribute of a function being executed to a task attribute recognizing function. A program execution function for inquiring of a task execution determination function about execution of a forced termination for a task to which the task belongs, and a task of determining the execution of the forced termination based on at least an attribute of a function being executed in response to the inquiry about the execution of the forced termination. Based on the execution determination function and the information on the attribute of the function transmitted from the program execution function, the attribute of the function being executed is stored in the storage means, and the execution function from the task execution function is stored. Task for returning the attribute of the function stored in the storage means in response to the attribute inquiry A computer-readable recording medium on which a program for realizing the attribute recognition function is recorded. 11. A digital device provided with an operating system for executing a plurality of tasks managed as one execution unit in parallel by a program execution means, wherein: task attribute information storage means for storing attribute of the task; The program execution means for sending information about the attribute of the task to the task attribute recognizing means, and inquiring the task attribute determining means of the execution of the forced termination for the task; and Task execution determining means for determining execution of the forced termination, and storing the attribute of the task in the task attribute information storage means based on the information on the attribute of the task transmitted from the program executing means. Inquiry of task attributes from task execution judgment means Against,
A digital device comprising: a task attribute recognizing unit that returns the attribute of the task stored in the task attribute information storage unit. 12. A task management method in an operating system for executing a plurality of tasks managed as one execution unit in parallel in an operating system, wherein an attribute of the task being executed is stored. A task management method characterized by determining whether or not the task being executed is forcibly terminated based on the stored task attributes. 13. A computer that executes a plurality of tasks managed as one execution unit in parallel by a program execution function, by transmitting information on the attribute of the executed task and executing forced termination of the task. A program execution function to be inquired; a task execution determination function to determine execution of the forced termination based on at least an attribute of a task being executed in response to an inquiry about execution of a forced termination from the program execution function; Based on the information on the attribute of the task transmitted from the means, the attribute of the task being executed is stored in the storage means, and in response to an inquiry about the attribute of the task being executed from the task execution determination function, Task attribute recognition function for returning the attribute of the task stored in the storage means And a program to realize it. 14. A computer that executes a plurality of tasks managed as one execution unit in parallel by a program execution function, by transmitting information on the attribute of the task being executed and executing forced termination on the task. A program execution function to be inquired; a task execution determination function to determine execution of the forced termination based on at least an attribute of a task being executed in response to an inquiry about execution of a forced termination from the program execution function; Based on the information on the attribute of the task transmitted from the function, the attribute of the task being executed is stored in the storage unit, and in response to an inquiry about the attribute of the task being executed from the task execution determination function, Task attribute recognition function for returning the attribute of the task stored in the storage means And a computer-readable recording medium on which a program for realizing the above is recorded.