System and Methods for Self-Healing From Operating System Faults in Kernel/Supervisory Mode

• US 20140032962A1
• Filed: 07/26/2012
• Published: 01/30/2014
• Est. Priority Date: 07/26/2012
• Status: Active Grant

• Current Assignee: Futurewei Technologies Incorporated (Huawei Investment & Holding Co., Ltd.)
• Original Assignee: Futurewei Technologies Incorporated (Huawei Investment & Holding Co., Ltd.)
• Inventors: Deshpande, Bhalchandra Dattatray
• Granted Patent: US 8,930,764 B2
• Time in Patent Office: Days
• US Class Current: 714/15
• CPC Class Codes: G06F 11/0706 the processing taking place on a specific hardware platform or in a specific software environment
• CPC Class Codes: G06F 11/0793 Remedial or corrective actions recovery from an exception in an instruction pipeline G06F9/3861; by retry G06F11/1402; for recovering from a failure of a protocol instance or entity H04L69/40

Abstract

A method, apparatus, and computing system are provided for self-healing from a fault in an operating system (OS) without crashing the OS. In one example, the method includes detecting, isolating, and repairing a faulty kernel code module without affecting the run-time operation of other, properly function, portions of the OS. In another example, the apparatus comprises a variety of modules, including, for instance, a kernel level fault detector and a kernel level fault manager, that are configured to execute steps of the method. In another example, the computing system includes an OS that has at least some modularized kernel code sections, and a self-healing code for detecting, isolating, and repairing failures occurring in one or more of the modularized kernel code sections without crashing the OS.

Claims

1. A method for self-healing from a fault in an operating system (OS), the method comprising:

detecting or predicting a fault in a kernel code of the OS, the kernel code comprising a plurality of kernel code modules;

determining that the fault is attributable to a faulty one of the plurality of kernel code modules;

isolating the faulty kernel code module from other ones of the plurality of kernel code modules; and

repairing the faulty kernel code module without crashing the OS.

2. The method of claim 1, wherein isolating the faulty kernel code comprises returning an error code to system processes that are executing the faulty kernel code module when the fault occurs.

3. The method of claim 2, wherein isolating the faulty kernel code further comprises:

suspending any new request for services of the faulty kernel code module that are made after detection of the fault, the new request being suspended until after the faulty kernel code module has been recovered or repaired.

4. The method of claim 1, wherein repairing the faulty kernel code module without crashing the OS comprises uninstalling and reinstalling the faulty kernel module without affecting run-time operations of other ones of the plurality of kernel code modules.

5. The method of claim 1 further comprising:

identifying one or more OS processes that operate at the user level and rely on services provided by the faulty kernel code module; and

shutting down or suspending the one or more identified OS processes.

6. The method of claim 5 further comprising:

pursuant to repairing the faulty kernel code module, restoring and re-initializing the faulty kernel code module; and

pursuant to restoring and re-initializing the faulty kernel code module, restoring the one or more identified OS processes.

7. An apparatus comprising:

a computer readable storage medium storing programming for execution by a processor, the programming including;

a kernel level fault detector comprising executable code for detecting or predicting a kernel level failure in an operating system (OS), the kernel level failure attributable to a faulty one of a plurality of kernel code modules; and

a kernel level fault manager comprising executable code for isolating the faulty kernel code module from other ones of the plurality of kernel code modules, and for repairing the faulty kernel code module without crashing the OS.

8. The apparatus of claim 7, wherein the executable code for isolating the faulty kernel code module includes executable code for returning an error code to system processes that are executing the faulty kernel code module when kernel level failure occurs.

9. The apparatus of claim 7, wherein the executable code for isolating the faulty kernel code module includes executable code for temporarily suspending one or more system calls for executing the faulty kernel code module while the faulty kernel code module is being repaired, and

wherein the one or more system calls are made by other kernel code modules or by system processes.

10. The apparatus of claim 7, wherein the executable code for repairing the faulty kernel code module without crashing the OS includes executable code for reinitializing the faulty kernel code module without interfering with run-time operation of other ones of the plurality of kernel code modules, the reinitializing including restoring an initial state of the faulty kernel code module as was established when the OS was first booted.

11. The apparatus of claim 7, wherein the executable code for repairing the faulty kernel code module without crashing the OS includes executable code for reloading the faulty kernel code module without interfering with run-time operation of other ones of the plurality of kernel code modules, the reloading including removing the faulty kernel code module from the OS, and thereafter loading a new kernel code module to the OS, the new kernel code module comprising executable code for providing similar services as the faulty kernel code module.

12. The apparatus of claim 11, wherein the executable code for repairing the faulty kernel code module without crashing the OS further includes executable code for locating and repairing a corrupted portion of the faulty kernel code module, thereby generating the new kernel code module, the corrupted portion of the faulty kernel code module being at least partially responsible for the kernel level failure.

13. The apparatus of claim 7, wherein the programming further includes:

a policy manager comprising executable code for managing the kernel level fault detector and the kernel level fault manager.

14. The apparatus of claim 13, wherein the policy manager comprises executable code indicating a module specific memory usage limit or pattern for the faulty kernel code module, and wherein the kernel level fault detector comprises executable code for detecting a memory leak in the faulty kernel code module in accordance with the module specific memory usage limit or pattern.

15. The apparatus of claim 7, wherein the programming further includes:

a crash analysis and debug module comprising executable code for identifying an underlying cause of the kernel level failure, the underlying cause corresponding to at least one of an illegal pointer access, a programmed crash point, a memory leak, and a deadlock.

16. The apparatus of claim 7, wherein the programming further includes:

a module specific fault manager comprising executable code for performing a set of tasks to repair the faulty kernel code module, the set of tasks being dependent on a type associated with the faulty kernel code module.

17. The apparatus of claim 16, wherein the executable code for performing the set of tasks includes executable code for:

making a fault assessment to identify a fault type and determine if any important data structures or data states have been damaged.

18. The apparatus of claim 16, wherein the executable code for performing a set of tasks includes executable code for:

identifying state information stored in a memory allocated by the faulty kernel code module;

storing the state information in a secure memory location prior to reinitializing the faulty kernel code module; and

restoring module specific data structures using the stored state information subsequent to rebooting the faulty kernel code module.

19. The apparatus of claim 7, wherein the programming further includes:

a module specific fault manager comprising executable code to identify and store debugging state information related to the faulty kernel code module; and

a crash analysis and debug module comprising executable code for debugging the faulty kernel code module based on the debugging state information.

20. The apparatus of claim 7, wherein the programming further includes:

a module specific fault manager comprising executable code for identifying one or more user level processes that rely on services provided by the faulty kernel code module; and

a user level fault manager comprising executable code for suspending the one or more identified user level processes pursuant to said identification by the module specific fault manager.

21. A computing system comprising:

a processor; and

a computer readable storage medium storing programming for execution by the processor, the programming including;

an operating system (OS) comprising a plurality of kernel code modules; and

self-healing code for detecting a faulty one of the plurality of kernel code modules, for isolating the faulty kernel code module from other ones of the plurality of kernel code modules, and for repairing the faulty kernel code module without crashing the OS.