Distributed kernel thread list processing for kernel patching

1. A method for patching a kernel comprising:

receiving an online patch request;

sending an interrupt to a plurality of hardware processor resources;

distributing a kernel thread list to the plurality of hardware processor resources;

dividing the kernel thread list into a plurality of portions based on a number of active processor resources;

parsing a portion of the kernel thread list on one of the plurality of hardware processor resources to determine when the portion is associated with a target function based on an instruction pointer of the target function;

determining a skip factor and a starting point based on the plurality of hardware processor resources;

traversing the kernel thread list a number of nodes based on the skip factor and the number of active processor resources;

processing a number of nodes equal to the skip factor beginning at the starting point; and

skipping the number of plurality of hardware processor resources over the kernel thread list based on the skip factor and a last processed node.

2. The method of claim 1 , comprising:

fetching the starting point by skipping the number of active processor resources times over the kernel thread list based on the skip factor and the last parsed node; and

maintaining a skip pointer on a first node to a second node, the second node to be a number of nodes equal to a skip factor from the first node.

3. The method of claim 1 , comprising:

aggregating a plurality of results of processing each portion to determine when an instruction pointer associated with the target function is in the kernel thread list, the kernel thread list to represent a segment of a memory resource associated with the kernel; and

waiting a time period to retrieve an updated kernel thread list.

4. The method of claim 1 , further comprising: patching the kernel when the kernel thread list is free of the target function.

5. A system for patching a kernel comprising:

a plurality of hardware processor resources;

a distribution engine to divide a kernel thread list into a number of portions, the portions to be distributed among the plurality of hardware processor resources; and

a handler engine to manage processing a portion of the kernel thread list to determine when a target function is associated with the portion of the kernel thread list,

wherein the distribution engine is further to:

set a flag to trigger processing by the handler engine and determine a skip factor and a starting point based on the plurality of hardware processor resources,

wherein the handler engine is further to:

determine when an instruction pointer of the target function is in the portion of the kernel thread list;

process the portion of the kernel thread list at the starting point;

process a number of nodes of the kernel thread list from the starting point, the number of nodes based on the skip factor; and

skip the number of the plurality of hardware processor resources over the kernel thread list based on the skip factor and a last processed node.

6. The system of claim 5 , comprising:

an interrupt engine to send a priority interrupt to the plurality of hardware processor resources, wherein:

the distribution engine is to halt operations of the plurality of hardware processor resources via the interrupt engine when a set of patch data is received; and

the handler engine is to:

process the number of portions in parallel to determine when the kernel thread list is free of the target function; and

return a set of results to the distribution engine.

7. The system of claim 5 , wherein the kernel is patched based on a determination that the kernel thread list is free of association of the target function.

8. A non-transitory machine readable storage medium comprising a set of instructions executable by a hardware processor resource to:

divide a kernel thread list of a kernel into a number of portions, the portions to be distributed among a plurality of processor resources;

manage processing a portion of the kernel thread list to determine when a target function is associated with the portion of the kernel thread list;

set a flag to trigger processing and determine a skip factor and a starting point based on the plurality of processor resources;

determine when an instruction pointer of the target function is in the portion of the kernel thread list;

process the portion of the kernel thread list at the starting point;

process a number of nodes of the kernel thread list from the starting point, the number of nodes based on the skip factor; and

skip the number of the plurality of processor resources over the kernel thread list based on the skip factor and a last processed node.

9. The medium of claim 8 , wherein the set of instructions is to:

send a priority interrupt to the plurality of processor resources; and

halt operations of the plurality of processor resources when a set of patch data is received.

10. The medium of claim 9 , wherein the set of instructions is to:

process the number of portions in parallel to determine when the kernel thread list is free of the target function; and

initiate patching of the kernel once the list is free of the target function.