CN106371942B

CN106371942B - Memory errors processing method and relevant apparatus and system

Info

Publication number: CN106371942B
Application number: CN201610743187.3A
Authority: CN
Inventors: 罗庆超; 张雷
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd
Priority date: 2016-08-27
Filing date: 2016-08-27
Publication date: 2019-05-03
Anticipated expiration: 2036-08-27
Also published as: CN106371942A

Abstract

The embodiment of the present application discloses memory errors processing method and relevant apparatus and system, and memory errors processing method includes: the first User space data access command for receiving User space application and sending；The first User space data access command is converted into the first scsi command；First scsi command is sent to the memory by SCSI protocol stack；When the first response for receiving the SCSI protocol transmission, first response indicates that first scsi command executes failure, first response carries memory error code, obtain the second scsi command for repairing the memory, the reparation operation instruction of second scsi command is corresponding with the memory error code, sends second scsi command to the memory by the SCSI protocol stack.The technical solution of the embodiment of the present application is conducive to the carry out memory error reparation of targeting.

Description

Memory error handling method and related apparatus and system

Technical Field

The present application relates to the field of computer technologies, and in particular, to a method for processing memory errors and a related apparatus and system.

Background

In a Computer System (e.g., a storage controller), a protocol stack for an operating System kernel (referred to as "kernel") to access a memory is usually a SCSI (Small Computer System Interface) protocol stack, where the memory is abstracted as a BLOCK (BLOCK) device, for example, a hard disk can be abstracted as one or more BLOCK devices. Based on the block device abstracted by the SCSI protocol stack, the user mode application accesses according to a POSIX (Portable Operating system interface).

In the prior art, when a memory abstracted as a block device is accessed by using a standard block device access command (such as a read/write command), if an access error occurs, only a simple error response (EIO) can be returned for the access error, which makes targeted error repair difficult.

Disclosure of Invention

The embodiment of the application provides a memory error processing method and a related device and system, which are beneficial to targeted memory error repair.

A first aspect of an embodiment of the present application provides a memory error handling method for a computer system, where the computer system may include: a user mode application, a Small Computer System Interface (SCSI) protocol stack, and a memory error handling component. The memory error handling component and the SCSI protocol stack are in a kernel mode of the computer system. The user-mode application is located in a user mode of the computer system.

The method comprises the following steps: when a user mode application needs to access a memory, the user mode application sends a first user mode data access command to the memory error processing component; after receiving a first user mode data access command sent by the user mode application, the memory error processing component converts the first user mode data access command into a first SCSI command, and sends the first SCSI command to the memory through a SCSI protocol stack;

the SCSI protocol stack sends the first SCSI command to the storage after receiving the first SCSI command; receiving an execution result of the memory on the first SCSI command, and sending a first response to the memory error processing component when the execution result indicates that the memory fails to execute the first SCSI command, wherein the first response indicates that the first SCSI command fails to execute, and the first response carries a memory error CODE (SENSE CODE).

And the memory error processing component acquires a second SCSI command for repairing the memory under the condition of receiving the first response sent by the SCSI protocol, wherein the repairing operation instruction of the second SCSI command corresponds to the memory error code, and the second SCSI command is sent to the memory through the SCSI protocol stack.

The method still further comprises: the memory executes the received first and second SCSI commands.

For example, when the second SCSI command is a restart command, the memory is restarted by executing the received second SCSI command; or when the second SCSI command is a reset command, the memory is reset by executing the received second SCSI command; or when the second SCSI command is an access start address adjustment command, the memory adjusts the access start address by executing the received second SCSI command.

The second SCSI command may be, for example, a restart command, a rewrite command, a reread command, a diagnostic command, or the like. Wherein the memory is highly likely to fix the corresponding error by executing the second SCSI command.

Optionally, in some possible implementations of the first aspect, the computer system further includes a block device corresponding to the memory, where the block device is located in a kernel state of the computer system; before the user-mode application sends the first user-mode data access command to the memory error handling component, the method further comprises:

the user mode application sends a second user mode data access command to the block device, and an intersection is formed between a data object requested to be accessed by the first user mode data access command and a data object requested to be accessed by the second user mode data access command;

the block device encapsulates the received second user mode data access command into a standard block device access command, and sends the standard block device access command to the SCSI protocol stack;

the SCSI protocol stack converts the received standard block equipment access command into a third SCSI command and sends the third SCSI command to the memory; receiving an execution result of the memory for the third SCSI command; when the execution result of the memory for the third SCSI command is that the execution of the third SCSI command fails, the SCSI protocol stack sends a response to the block device indicating that the execution of the standard block device access command failed,

the block device, after receiving a response from the SCSI protocol stack indicating that execution of the standard block device access command failed, sends a response to the user-mode application indicating that execution of the second user-mode data access command failed;

and the user mode application receives a response which is sent by the block device and indicates that the second user mode data access command fails to be executed.

In the above example, the user-mode application may prioritize data access through the block device, and after finding that data access through the block device fails, perform the same or similar data access through the memory error handling component. Of course, the user-mode application may also select whether to access data through the memory error handling component or through the block device based on other policies.

A second aspect of the embodiments of the present application provides a memory error processing method, including: receiving a first user mode data access command sent by a user mode application; converting the first user-mode data access command into a first Small Computer System Interface (SCSI) command; sending the first SCSI command to the memory through a SCSI protocol stack; when a first response sent by the SCSI protocol is received, the first response indicates that the execution of the first SCSI command fails, the first response carries a memory error code, a second SCSI command for repairing the memory is obtained, wherein the repairing operation indication of the second SCSI command corresponds to the memory error code, and the second SCSI command is sent to the memory through the SCSI protocol stack.

A third aspect of embodiments of the present application provides a computer system, including: a user-mode application, a memory error handling component, and a Small Computer System Interface (SCSI) protocol stack, wherein the memory error handling component and the SCSI protocol stack are located in a kernel mode of the computer system;

the user-mode application is used for sending a first user-mode data access command to the memory error processing component;

the memory error processing component is configured to, after receiving a first user-mode data access command sent by the user-mode application, convert the first user-mode data access command into a first SCSI command, and send the first SCSI command to the memory through a SCSI protocol stack;

the SCSI protocol stack is configured to send the first SCSI command to the storage after receiving the first SCSI command; receiving an execution result of the first SCSI command by the storage, and sending a first response to the storage error processing component when the execution result indicates that the first SCSI command fails to be executed by the storage, wherein the first response indicates that the first SCSI command fails to be executed, and the first response carries a storage error code;

the memory error processing component is configured to, in a case where the first response sent by the SCSI protocol is received, acquire a second SCSI command for repairing the memory, where a repair operation instruction of the second SCSI command corresponds to the memory error code, and send the second SCSI command to the memory through the SCSI protocol stack.

Optionally, in some possible embodiments of the third aspect, the computer system further includes a block device corresponding to the memory, where the block device is located in a kernel state of the computer system.

Wherein the user-state application is further configured to send a second user-state data access command to the block device before sending a first user-state data access command to the memory error handling component, the data object requested to be accessed by the first user-state data access command having an intersection with the data object requested to be accessed by the second user-state data access command;

the block device is configured to encapsulate the received second user-state data access command into a standard block device access command, and send the standard block device access command to the SCSI protocol stack;

the SCSI protocol stack is also used for converting the received standard block device access command into a third SCSI command and sending the third SCSI command to the memory; receiving an execution result of the memory for the third SCSI command; when the execution result of the memory for the third SCSI command is failure to execute the third SCSI command, sending a response to the block device indicating that the standard block device access command failed to execute,

the block device is further configured to, after receiving a response from the SCSI protocol stack indicating that the standard block device access command failed to execute, send a response to the user-mode application indicating that the second user-mode data access command failed to execute;

the user-mode application is further configured to receive a response sent by the block device indicating that the second user-mode data access command failed to be executed.

A fourth aspect of the embodiments of the present application provides a memory error processing apparatus, including:

the receiving unit is used for receiving a first user mode data access command sent by a user mode application;

a conversion unit to convert the first user mode data access command into a first Small Computer System Interface (SCSI) command;

a sending unit, configured to send the first SCSI command to the storage through an SCSI protocol stack;

a repairing unit, configured to, when a first response sent by the SCSI protocol is received, obtain a second SCSI command for repairing the memory, where the first response indicates that the first SCSI command fails to be executed, and the first response carries a memory error code, and a repairing operation indication of the second SCSI command corresponds to the memory error code;

the sending unit is further configured to send the second SCSI command to the storage through the SCSI protocol stack.

Further, in the solutions provided in the above aspects of the present application, the second SCSI command for repairing the memory may be obtained in various ways.

For example, the obtaining the second SCSI command to repair the memory may comprise: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; and generating a second SCSI command matched with the error processing strategy based on the error processing strategy.

For another example, the obtaining the second SCSI command to repair the memory may include: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; sending the error handling policy to the user-mode application; receiving the second SCSI command sent by the user-mode application by calling an error handling function matched with the error handling policy.

The above examples provide some repair processing mechanisms in which both the memory error processing component and the user mode application can participate, which is beneficial to meeting flexible repair processing requirements in different scenarios.

The method is beneficial to constructing the ecology of the memory by introducing the error processing plug-in of the manufacturer to which the memory belongs, and rapidly applying the repair processing technology of the corresponding memory manufacturer to the system, thereby being beneficial to further improving the stability and reliability of the system.

Further, in the solutions provided in the above aspects of the present application, the second SCSI command further carries a storage parameter adjustment value, and the second SCSI command is further configured to instruct the storage to perform parameter adjustment based on the storage parameter adjustment value.

Further, in aspects of the present application provided in the foregoing aspects, the memory parameter adjustment value includes a retry number adjustment value and/or a timeout parameter adjustment value.

It can be seen that modifying some memory parameters becomes feasible due to the provision of a mechanism for modifying memory parameters. For example, by reducing the number of retries and/or increasing the timeout parameter, it may be advantageous to reduce kernel error handling time.

Further, in the technical solutions provided in the above aspects of the present application, the memory may be, for example, a Shingled (SMR) hard disk or other types of hard disks.

Furthermore, a fifth aspect of embodiments herein provides a computer-readable storage medium storing program code for memory repair processing. The program code comprises instructions for performing the method of the first aspect or the second aspect.

A sixth aspect of the present embodiment further provides a memory error processing apparatus, which may include: the memory and the processor are used for executing part or all of operations executed by the memory error processing component in any one of the memory error processing methods provided by the application by calling instructions or codes stored in the memory.

It can be seen that, the scheme of the application introduces the memory error handling component, so that the interaction between the user mode application and the SCSI protocol stack does not depend on the unique intermediate bridge of the block device any more, and a second channel is opened up for the interaction between the user mode application and the SCSI protocol stack, that is, the user mode application can indirectly access the SCSI protocol stack through the memory error handling component, and then access the memory. Therefore, the flexibility of user mode application data access is higher, and the error resistance is favorably improved. In addition, because the block device accesses the SCSI protocol stack using a standard block device access command (e.g., a read/write command), and the SCSI protocol stack usually returns a simple error response (EIO) to the block device when an access error occurs for the access method agreed in the related protocol, and the EIO does not reflect a specific reason for the access error, it is difficult to perform targeted error repair. In the technical scheme of the application, the memory error processing component converts the first user-mode data access command from the user-mode application into the first SCSI command, and then forwards the first SCSI command to the memory for execution through the SCSI protocol stack, and the SCSI protocol stack can feed back the relevant response carrying the memory error code for the SCSI-type access command, so that when an access error occurs, the memory error processing component can obtain the relevant error reason based on the memory error fed back by the SCSI protocol stack, thereby facilitating more targeted (targeted) repair of the relevant error and further facilitating improvement of the stability and reliability of the system.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the embodiments will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings without creative efforts.

FIGS. 1-A-1-D are schematic diagrams of several computer systems according to embodiments of the present disclosure;

FIG. 2 is a flowchart illustrating a method for processing a memory error according to an embodiment of the present disclosure;

FIG. 3-A is a flow chart illustrating another memory error handling method according to an embodiment of the present disclosure;

FIG. 3-B is a diagram illustrating a mapping table according to an embodiment of the present application;

FIG. 4-A is a flow chart illustrating another memory error handling method according to an embodiment of the present disclosure;

FIG. 4-B is a diagram of another mapping table provided in an embodiment of the present application;

FIG. 4-C is a diagram of another mapping table provided in an embodiment of the present application;

FIG. 5 is a diagram illustrating a computer system according to an embodiment of the present application;

FIG. 6 is a diagram illustrating an apparatus for memory error handling according to an embodiment of the present disclosure;

fig. 7 is a schematic diagram of a memory error handling apparatus according to an embodiment of the present disclosure.

Detailed Description

The terms "comprising" and "having," and any variations thereof, as appearing in the specification, claims and drawings of this application, are intended to cover non-exclusive inclusions. For example, a process, method, system, article, or apparatus that comprises a list of steps or elements is not limited to only those steps or elements listed, but may alternatively include other steps or elements not listed, or inherent to such process, method, article, or apparatus. Furthermore, the terms "first," "second," and "third," etc. are used to distinguish between different objects and are not used to describe a particular order.

Please refer to fig. 1-a to fig. 1-D first. Where FIG. 1-A illustrates a conventional architecture of a computer system, the memory of the hardware layer is abstracted into BLOCK (BLOCK) devices, which are accessed by user-mode applications in accordance with POSIX. Components in the operating system kernel (e.g., block devices, etc.) access memory through the SCSI protocol stack.

FIG. 1-B shows a computer system architecture provided by way of example in an embodiment of the present application, in which memory error handling components are added functional components to the present application. After the memory error handling component is added, the user mode application can access the memory through the memory error handling component and the SCSI protocol stack. The memory error handling component also has other product names.

FIGS. 1-C illustrate some components that a SCSI protocol stack may include, for example, a bottom layer component (e.g., SCSI Low Level driver), a Middle layer component (e.g., SCSI Middle Level driver), and an upper layer component (e.g., SD-SCSI Device and SG-SCSI Generic, etc.). Of course, such a division of components by the SCSI protocol stack is illustrative and not limiting.

1-D illustrate some of the components that a memory error handling component may include, for example, a regulation unit, a relay unit, and a repair unit. Of course, such component division is illustrative and not limiting.

The memory referred to by the embodiments of the present application may be a Shingled (SMR) hard disk or other type of solid state disk or other type of memory.

In the conventional technology, for the SCSI protocol stack and the BLOCK device to interact directly based on the standard BLOCK device interaction flow, therefore, for the response carrying the memory error code from the memory, the SCSI protocol stack will mask off the memory error code carried in the response, and therefore, the BLOCK device will not obtain the memory error code, which results in that the user mode application based on the BLOCK device cannot learn any memory error code related thereto.

The BLOCK device is obtained by abstracting a memory, and 1 memory may be abstracted to 1 or more BLOCK devices, and a plurality of memories may also be abstracted to 1 BLOCK device. The logic memory space in the BLOCK device corresponds to the physical memory space in the memory, and the BLOCK device is used for users or systems.

The following is a detailed description through specific exemplary scenarios.

Referring to fig. 2, fig. 2 is a flowchart illustrating a memory error handling method according to an embodiment of the present application. The memory error handling method illustrated in FIG. 2 may be implemented based on the architecture illustrated in any of FIGS. 1-B-1-D. Referring to fig. 2, an embodiment of the present application provides a memory error handling method, which may include:

201. for example, when the user-mode application needs to access the memory, the user-mode application sends a first user-mode data access command to the memory error handling component.

202. The memory error processing component receives the first user-mode data access command sent by the user-mode application; the memory error handling component converts the first user-mode data access command to a first SCSI command.

It will be appreciated that the data access type of the first user mode data access command and the first SCSI command are the same, and the data access type may be, for example, read or write, or the like. For example, the first user-mode data access command is a user-mode data read command, and the first SCSI command is a SCSI read command. For another example, if the first user-mode data access command is a user-mode data write command, then the first SCSI command is a SCSI write command, and so on.

203. And the memory error processing component sends the first SCSI command to the memory through a SCSI protocol stack. Wherein the memory may execute the first SCSI command after receiving the first SCSI command sent by the SCSI protocol stack, and the memory may send an execution result of the first SCSI command to the SCSI protocol stack, where the execution result may indicate that the first SCSI command is executed unsuccessfully or successfully.

After the SCSI protocol stack receives the execution result of the first SCSI command sent by the memory, if the execution result indicates that the first SCSI command fails to be executed, the SCSI protocol stack may send a first response indicating that the first SCSI command fails to be executed to the memory error processing component, where the first response carries a corresponding memory error code, and the memory error code may reflect, to some extent, a reason for the first SCSI command failing to be executed. Further, if the execution result indicates that the first SCSI command was successfully executed, the SCSI protocol stack may send a second response to the memory error handling component indicating that the first SCSI command was successfully executed.

204. And if the memory error processing component receives a first response which is sent by the SCSI protocol and indicates that the execution of the first SCSI command fails and the first response carries a memory error code, acquiring a second SCSI command for repairing the memory, wherein a repairing operation instruction of the second SCSI command corresponds to the memory error code.

205. And the memory error processing component sends the second SCSI command to the memory through the SCSI protocol stack. The second SCSI command may be, for example, a restart command, a reset command, an access start address adjustment command, a rewrite command, a reread command, a diagnostic command, or the like. The memory is likely to fix the corresponding error by executing the second SCSI command.

It can be seen that, in the solution of this embodiment, a memory error handling component is introduced, so that the interaction between the user-mode application and the SCSI protocol stack does not depend on the unique intermediate bridge of the block device any more, and a second channel is opened up for the interaction between the user-mode application and the SCSI protocol stack, that is, the user-mode application can indirectly access the SCSI protocol stack through the memory error handling component, and then access the memory. Therefore, the flexibility of user mode application data access is higher, and the error resistance is favorably improved. In addition, because the block device accesses the SCSI protocol stack using a standard block device access command (e.g., a read/write command), and the SCSI protocol stack usually returns a simple error response (EIO) to the block device when an access error occurs for the access method agreed in the related protocol, and the EIO does not reflect a specific reason for the access error, it is difficult to perform targeted error repair. In the solution of this embodiment, the memory error processing component converts the first user-state data access command from the user-state application into the first SCSI command, and then forwards the first SCSI command to the memory for execution through the SCSI protocol stack, and the SCSI protocol stack can feed back a relevant response carrying a memory error CODE (SENSE CODE) for the SCSI-form access command, so that when an access error occurs, the memory error processing component can learn a relevant error cause based on the memory error fed back by the SCSI protocol stack, thereby facilitating more targeted (targeted) repair of the relevant error, and further facilitating improvement of system stability and reliability.

Wherein the memory error handling component may obtain the second SCSI command corresponding to the memory error code for repairing the memory in a plurality of ways.

For example, the obtaining a second SCSI command corresponding to the memory error code for repairing the memory may comprise: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; and searching a second SCSI command which is matched with the error processing strategy and used for repairing the memory based on the error processing strategy.

For another example, the obtaining a second SCSI command corresponding to the memory error code for repairing the memory may comprise: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; sending the error handling policy to the user-mode application; receiving the second SCSI command sent by the user-mode application by calling an error handling function matched with the error handling policy.

Further, the second SCSI command or the first SCSI command may also carry a storage parameter adjustment value. The memory parameter adjustment value may include, for example, a retry number adjustment value and/or a timeout parameter adjustment value. By reducing the number of retries and/or increasing the timeout parameter, it is beneficial to reduce kernel error handling time.

Optionally, before receiving the first user-mode data access command sent by the user-mode application, the method further includes: the user mode application sends a second user mode data access command to the block device corresponding to the memory, and an intersection is formed between a data object requested to be accessed by the first user mode data access command and a data object requested to be accessed by the second user mode data access command; and the user mode application receives a response which is sent by the block device and indicates that the second user mode data access command fails to be executed.

Specifically, for example, before receiving the first user-mode data access command sent by the user-mode application, the method further includes: the user mode application sends a second user mode data access command to the block device corresponding to the memory, and an intersection is formed between a data object requested to be accessed by the first user mode data access command and a data object requested to be accessed by the second user mode data access command; after receiving the second user mode data access command, the block device encapsulates the second user mode data access command into a standard block device access command and sends the standard block device access command to an SCSI protocol stack; after receiving the standard block device access command, the SCSI protocol stack converts the standard block device access command into a third SCSI command, sends the third SCSI command to the storage for execution, and receives an execution result of the third SCSI command execution sent by the storage (the execution result indicates that the third SCSI command is executed successfully or unsuccessfully).

When the third SCSI command fails to execute, the SCSI protocol stack may send a response to the block device indicating that the standard block device access command failed to execute, and when the third SCSI command succeeds in executing, the SCSI protocol stack may send a response to the block device indicating that the standard block device access command succeeded in executing.

After the block device receives a response from the SCSI protocol stack indicating that the standard block device access command failed to execute, the block device may, for example, send a response to the user-mode application indicating that the user-mode data access command failed to execute. And after the block device receives a response from the SCSI protocol stack indicating successful execution of the standard block device access command, the block device may, for example, send a success to the user-mode application indicating a failure in execution of the user-mode data access command. Accordingly, the user-mode application may learn the results of the execution of the user-mode data access commands based on the respective responses fed back by the block devices.

Referring to fig. 3-a, fig. 3-a is a schematic flow chart illustrating a memory error handling method according to an embodiment of the present application. The memory error handling method illustrated in FIG. 3-A may be implemented based on the architecture illustrated in any of FIGS. 1-B-1-D. Referring to fig. 3-a, another embodiment of the present application provides another memory error handling method, which may include:

301. the user-mode application sends a user-mode data access command Q1 to the block device (BLACK).

302. The block device (BLACK) receives the user-mode data access command Q1 sent by the user-mode application. The block device encapsulates the user-state data access command Q1 as a standard block device access command BQ 1. The block device sends the standard block device access command BQ1 to the SCSI protocol stack.

303. The SCSI protocol stack receives the standard block device access command, converts the standard block device access command into a SCSI command SQ1, and sends the SCSI command SQ1 to a memory corresponding to the block device for execution.

304. The memory receives the SCSI command SQ 1.

The storage executes the SCSI command SQ1, and the storage sends the execution result of the SCSI command SQ1 to the SCSI protocol stack. Wherein, this execution result may indicate success or failure of the memory to execute the SCSI command SQ 1. If the execution result indicates that the memory successfully executes the SCSI command SQ1 command, it indicates that the memory was successfully accessed. If the result of the execution indicates that the memory failed to execute the SCSI command SQ1, it indicates that the memory access failed.

305. And the SCSI protocol stack receives the execution result of the SCSI command SQ1 sent by the memory.

If the memory successfully executes the SCSI command SQ1, the SCSI protocol stack sends a response BQA1-1 to the block device indicating that the standard block device access command BQ1 was successfully executed (if the standard block device access command is a data read command, then the response BQA1-1 may carry read data). If the memory fails to execute the SCSI command SQ1, the SCSI protocol stack sends a response BQA1-2(EIO) to the block device indicating that the standard block device access command BQ1 failed to execute, the response BQA1-2 not carrying a memory error CODE (SENSE CODE).

306. The block device receives either response BQA1-1 or response BQA 1-2.

Wherein, if the block device receives a response BQA1-1 (indicating that the standard block device access command BQ1 was successfully executed), the block device sends a response QA1-1 to the user-mode application indicating that the user-mode data access command Q1 was successfully executed. If the block device receives a response BQA1-2 indicating that the standard block device access command BQ1 failed to execute, the block device sends a response QA1-2 to the user-state application indicating that the user-state data access command Q1 failed to execute.

307. The user mode application receives either response QA1-1 or response QA1-2 sent by the block device. If the user-mode application receives QA1-2 (indicating a failure to access the memory), the user-mode application sends a user-mode data access command Q2 to the memory error handling component. Wherein the data objects requested to be accessed by the user-state data access command Q2 have an intersection with the data objects requested to be accessed by the user-state data access command Q1.

For example, the data objects requested to be accessed by the user-mode data access command Q2 are a subset of the data objects requested to be accessed by the user-mode data access command Q1. For example, the data objects requested to be accessed by the user-state data access command Q1 are data _01, data _02 and data _03, the data objects requested to be accessed by the user-state data access command Q2 may include at least 1 of data _01, data _02 and data _03, and the data objects requested to be accessed by the user-state data access command Q2 may further include other data objects.

Specifically, for example, the address space of the data object requested to be accessed carried by the user-mode data access command Q2 is a subset of the address space of the data object requested to be accessed carried by the user-mode data access command Q1. For example, the address space of the data object requested to be accessed by the user-state data access command Q1 is add0001 to add0010, the address space of the data object requested to be accessed by the user-state data access command Q2 may be part or all of add0001 to add0010, and the data object requested to be accessed by the user-state data access command Q2 may further include other address spaces.

308. The memory error handling component receives the user state data access command Q2, the memory error handling component converts the user state data access command Q2 to a SCSI command SQ 2; the memory error handling component sends the SCSI command SQ2 to the SCSI protocol stack.

309. The SCSI protocol stack receives the SCSI command SQ2, and the SCSI protocol stack sends the SCSI command SQ2 to the storage for execution.

310. The memory receives the SCSI command SQ 2.

The storage executes the SCSI command SQ2, and the storage sends the execution result of the SCSI command SQ2 to the SCSI protocol stack. Wherein, this execution result may indicate success or failure of the memory to execute the SCSI command SQ2, and if the execution result indicates success of the memory to execute the SCSI command SQ2, it indicates success in accessing the memory. If the result of the execution indicates that the memory failed to execute the SCSI command SQ2, it indicates that the memory access failed.

311. And the SCSI protocol stack receives the execution result of the SCSI command SQ2 sent by the memory.

If the memory successfully executes the SCSI command SQ2, the SCSI protocol stack sends a response SQA2-1 to the memory error handling component indicating that the SCSI command SQ2 successfully executes (if SCSI command SQ2 is a data read command, then response SQA2-1 may carry read data). If the storage fails to execute the SCSI command SQ2, the SCSI protocol stack sends a response SQA2-2 indicating that the SCSI command SQ2 fails to execute to the storage error handling component, and the response SQA2-2 carries a storage error CODE (SENSE CODE).

312. The memory error handling component receives either a response SQA2-1 or a response SQA 2-2. If the memory error processing component receives a response SQA2-2 (indicating that the memory access is failed), the memory error processing component calls an error processing plug-in corresponding to a manufacturer to which the memory belongs to analyze the memory error code, the error processing plug-in searches a corresponding error processing strategy according to the memory error code, and the error processing plug-in returns the searched error processing strategy to the memory error processing component.

313. If the memory error handling component receives the response SQA2-1, the memory error handling component sends a response QA2-1 to the user-mode application indicating that the user-mode data access command Q2 was successfully executed. If the memory error handling component receives a response SQA2-2, the memory error handling component sends a response QA2-2 to the user-mode application indicating that the user-mode data access command Q2 failed to execute, wherein the response QA2-2 carries the error handling policy.

314. The user mode application receives either the response QA2-1 or response QA 2-2.

The following flow mainly takes the user mode application receiving the response QA2-2 as an example.

And the user mode application searches an error processing function corresponding to the error processing strategy according to the error processing strategy and sends an SCSI command SX3 to the memory error processing component by calling the searched error processing function.

Referring to FIG. 3-B, FIG. 3-B illustrates a possible correspondence between memory error codes, error handling policies, error handling functions, and related SCSI commands. The example shown in fig. 3-B is to record the correspondence between the memory error code, the error handling policy, the error handling function and the related SCSI command through the mapping table, but is not limited to the use of the mapping table.

315. The memory error handling component receives the SCSI command SX3, and the memory error handling component sends the SCSI command SX3 to the SCSI protocol stack. The SCSI command SX3 may be, for example, a restart command, or an overwrite command, or a reread command, or a diagnostic command, etc.

316. The SCSI protocol stack receives the SCSI command SX3, and the SCSI protocol stack sends the SCSI command SX3 to the memory for execution.

317. The memory receives the SCSI command SX 3.

The memory executes the SCSI command SX3, and the memory sends the execution result of the SCSI command SX3 to the SCSI protocol stack. The execution result may indicate that the memory successfully or unsuccessfully executes the SCSI command SX3, indicate that the memory is successfully repaired if the execution result indicates that the memory successfully executes the SCSI command SX3, and indicate that the memory is unsuccessfully repaired if the execution result indicates that the memory unsuccessfully executes the SCSI command SX 3.

318. The SCSI protocol stack receives the execution result of the SCSI command SX3 sent by the memory. The SCSI protocol stack sends the result of the execution of the SCSI command SX3 by the memory to the memory error handling component.

319. The memory error handling component receives the execution result of the SCSI command SX3 from the SCSI protocol stack. The memory error handling component sends the result of the execution of the SCSI command SX3 by the memory to the user mode application.

Accordingly, the user mode application receives the execution result of the SCSI command SX3 sent by the memory error processing component, and the user mode application may display the execution result of the SCSI command SX3 by the memory, for example. Where this execution result indicates either a memory repair failure or a memory repair success. For example, if the execution result indicates a failure to repair memory, the user-mode application may issue an alert (e.g., in the form of a voice, text, and/or picture) requesting manual intervention.

In addition, SCSI command SQ1 or the SCSI command SX3 may also carry a memory parameter adjustment value. The memory parameter adjustment value may include, for example, a retry number adjustment value and/or a timeout parameter adjustment value. By reducing the number of retries and/or increasing the timeout parameter, it is beneficial to reduce kernel error handling time. Of course, the memory error processing component may also carry the memory parameter adjustment value through other SCSI commands, and send the SCSI command carrying the memory parameter adjustment value to the memory through the SCSI protocol stack for execution, thereby adjusting the memory parameter. The memory can also feed back the adjustment result of the memory parameter to the memory error processing component through the SCSI protocol stack. The adjustment of the memory parameters may be initiated by the user mode application or initiated by other methods.

Referring to fig. 4, fig. 4 is a flowchart illustrating a memory error handling method according to an embodiment of the present application. The memory error handling method illustrated in FIG. 4 may be implemented based on the architecture illustrated in any of FIGS. 1-B-1-D. Referring to fig. 4, another embodiment of the present application provides another memory error handling method, which may include:

401. the user-mode application sends a user-mode data access command Q1 to the block device (BLACK).

402. The block device (BLACK) receives the user-mode data access command Q1 sent by the user-mode application. The block device encapsulates the user-state data access command Q1 as a standard block device access command BQ 1. The block device sends the standard block device access command BQ1 to the SCSI protocol stack.

403. The SCSI protocol stack receives the standard block device access command, converts the standard block device access command into a SCSI command SQ1, and sends the SCSI command SQ1 to a memory corresponding to the block device for execution.

404. The memory receives the SCSI command SQ 1.

405. And the SCSI protocol stack receives the execution result of the SCSI command SQ1 sent by the memory.

406. The block device receives either response BQA1-1 or response BQA 1-2.

407. The user mode application receives either response QA1-1 or response QA1-2 sent by the block device. If the user-mode application receives QA1-2 (indicating a failure to access the memory), the user-mode application sends a user-mode data access command Q2 to the memory error handling component. Wherein the data objects requested to be accessed by the user-state data access command Q2 have an intersection with the data objects requested to be accessed by the user-state data access command Q1.

408. The memory error handling component receives the user-state data access command Q2, which converts the user-state data access command Q2 into a SCSI command SQ 2. The memory error handling component sends the SCSI command SQ2 to the SCSI protocol stack.

409. The SCSI protocol stack receives the SCSI command SQ2, and the SCSI protocol stack sends the SCSI command SQ2 to the storage for execution.

410. The memory receives the SCSI command SQ 2.

411. And the SCSI protocol stack receives the execution result of the SCSI command SQ2 sent by the memory.

412. The memory error handling component receives either a response SQA2-1 or a response SQA 2-2. If the memory error handling component receives the response SQA2-1, the memory error handling component sends a response QA2-1 to the user-mode application indicating that the user-mode data access command Q2 was successfully executed. If the memory error handling component receives the response SQA2-2, the memory error handling component sends a response QA2-2 to the user-mode application indicating that the user-mode data access command Q2 failed to execute.

The user mode application receives either the response QA2-1 or response QA 2-2.

The following flow mainly takes the case that the memory error processing component receives the response SQA2-2 as an example.

413. If the memory error processing component receives a response SQA2-2 (indicating that the memory access is failed), the memory error processing component calls an error processing plug-in corresponding to a manufacturer to which the memory belongs to analyze the memory error code, the error processing plug-in searches a corresponding error processing strategy according to the memory error code, and the error processing plug-in returns the searched error processing strategy to the memory error processing component.

Referring to FIG. 4-B, FIG. 4-B illustrates a possible correspondence between memory error codes, error handling policies, and related SCSI commands. The example shown in fig. 4-B is for recording the correspondence between the memory error code, the error handling policy and the related SCSI command through a mapping table, but is not limited to the use of the mapping table.

Referring to fig. 4-C, fig. 4-C illustrates a possible specific correspondence between the memory error codes and error handling policies. Of course, the correspondence between the memory error codes and the error handling policies is not limited to the example shown in fig. 4-C.

414. The memory looks up a SCSI command SX3 for repairing the memory that matches the error handling policy based on the error handling policy.

415. The memory error handling component sends the SCSI command SX3 to the SCSI protocol stack. The SCSI command SX3 may be, for example, a restart command, or an overwrite command, or a reread command, or a diagnostic command, etc.

416. The SCSI protocol stack receives the SCSI command SX3, and the SCSI protocol stack sends the SCSI command SX3 to the memory for execution.

417. The memory receives the SCSI command SX 3.

418. The SCSI protocol stack receives the execution result of the SCSI command SX3 sent by the memory. The SCSI protocol stack sends the result of the execution of the SCSI command SX3 by the memory to the memory error handling component.

419. The memory error handling component receives the execution result of the SCSI command SX3 from the SCSI protocol stack. The memory error handling component may further send the results of the execution of the SCSI command SX3 by the memory to the user-mode application.

When the above-mentioned scheme is implemented based on the architecture shown in fig. 1-D, the adjustment adjusting unit in the memory error processing component may be used to perform adjustment of relevant memory parameters, the relay unit may be used to perform translation and forwarding of relevant commands, and the repair unit may be used to perform relevant repair of memory errors. Of course, such a division of components and division of time are illustrative and not restrictive.

Some related devices for implementing the above-described embodiments are also provided below.

Referring to fig. 5, an embodiment of the present application provides a computer system 500, including:

a user mode application 510, a memory error handling component 520, and a Small Computer System Interface (SCSI) protocol stack 530, wherein the memory error handling component 510 and the SCSI protocol stack 520 are in a kernel mode of the computer system.

The user-mode application 510 may be configured to send a first user-mode data access command to the memory error handling component.

The memory error processing component 520 is configured to, after receiving a first user-mode data access command sent by the user-mode application, convert the first user-mode data access command into a first SCSI command, and send the first SCSI command to the memory through a SCSI protocol stack;

the SCSI protocol stack 530, operable to send the first SCSI command to the memory after receiving the first SCSI command; receiving an execution result of the first SCSI command by the storage, and sending a first response to the storage error processing component when the execution result indicates that the first SCSI command fails to be executed by the storage, wherein the first response indicates that the first SCSI command fails to be executed, and the first response carries a storage error code;

the memory error processing component 520 is configured to, in a case where the first response sent by the SCSI protocol is received, obtain a second SCSI command for repairing the memory, where a repair operation instruction of the second SCSI command corresponds to the memory error code, and send the second SCSI command to the memory through the SCSI protocol stack.

Optionally, in some possible embodiments, the computer system 500 may further include a block device 540 corresponding to the memory, where the block device 540 is located in a kernel state of the computer system.

The user-state application 510 is further configured to send a second user-state data access command to the block device before sending a first user-state data access command to the memory error processing component 520, where the data object requested to be accessed by the first user-state data access command has an intersection with the data object requested to be accessed by the second user-state data access command;

the block device 540 is configured to encapsulate the received second user-state data access command into a standard block device access command, and send the standard block device access command to the SCSI protocol stack;

the SCSI protocol stack 530 is further configured to convert the received standard block device access command into a third SCSI command, and send the third SCSI command to the storage; receiving an execution result of the memory for the third SCSI command; when the execution result of the memory for the third SCSI command is that the third SCSI command fails to be executed, sending a response indicating that the standard block device access command fails to be executed to the block device.

The block device 540 is further configured to send a response to the user-mode application indicating that the second user-mode data access command failed to execute after receiving a response from the SCSI protocol stack indicating that the standard block device access command failed to execute.

The user-mode application 510 is further configured to receive a response sent by the block device indicating that the second user-mode data access command failed to execute.

Further, the memory error handling component 520 may obtain the second SCSI command used to repair the memory in a variety of ways.

Further, in some possible embodiments, the second SCSI command also carries a memory parameter adjustment value, and the second SCSI command is also used to instruct the memory to perform a parameter adjustment based on the memory parameter adjustment value.

Further, in some possible embodiments, the memory parameter adjustment value comprises a retry number adjustment value and/or a timeout parameter adjustment value.

Further, the computer system 500 further comprises a memory 550, wherein the memory 550 is configured to execute the received first SCSI command and the second SCSI command. For example, the memory 550 is configured to execute the received second SCSI command to perform a reboot when the second SCSI command is a reboot command; or when the second SCSI command is a reset command, resetting by executing the received second SCSI command; or when the second SCSI command is an access starting address adjusting command, adjusting the access starting address by executing the received second SCSI command.

Further, in some possible embodiments, the memory may be, for example, a Shingled (SMR) hard disk or other type of hard disk.

It can be seen that the memory error handling component 520 is introduced in the solution of the present application, so that the interaction between the user mode application and the SCSI protocol stack does not depend on the unique intermediate bridge of the block device any more, and a second channel is opened up for the interaction between the user mode application and the SCSI protocol stack, that is, the user mode application can indirectly access the SCSI protocol stack through the memory error handling component, and then access the memory. Therefore, the flexibility of user mode application data access is higher, and the error resistance is favorably improved. In addition, because the block device accesses the SCSI protocol stack using a standard block device access command (e.g., a read/write command), and the SCSI protocol stack usually returns a simple error response (EIO) to the block device when an access error occurs for the access method agreed in the related protocol, and the EIO does not reflect a specific reason for the access error, it is difficult to perform targeted error repair. In the technical scheme of the application, the memory error processing component converts the first user-mode data access command from the user-mode application into the first SCSI command, and then forwards the first SCSI command to the memory for execution through the SCSI protocol stack, and the SCSI protocol stack can feed back the relevant response carrying the memory error code for the SCSI-type access command, so that when an access error occurs, the memory error processing component can obtain the relevant error reason based on the memory error fed back by the SCSI protocol stack, thereby facilitating more targeted (targeted) repair of the relevant error and further facilitating improvement of the stability and reliability of the system.

Referring to fig. 6, an embodiment of the present application provides a memory error handling apparatus 600, including: a receiving unit 610, a converting unit 620, a transmitting unit 630 and a repairing unit 640.

The receiving unit 610 may be configured to receive a first user-mode data access command sent by a user-mode application.

A converting unit 620, configured to convert the first user mode data access command into a first Small Computer System Interface (SCSI) command.

A sending unit 630, configured to send the first SCSI command to the storage through a SCSI protocol stack.

A repairing unit 640, configured to, when receiving a first response sent by the SCSI protocol, where the first response indicates that the first SCSI command fails to be executed, and the first response carries a memory error code, acquire a second SCSI command for repairing the memory, where a repairing operation indication of the second SCSI command corresponds to the memory error code.

The sending unit 630 is further configured to send the second SCSI command to the storage through the SCSI protocol stack.

Further, in some possible embodiments, the second SCSI command also carries a memory parameter adjustment value, and the second SCSI command is also used to instruct the memory to perform a parameter adjustment based on the memory parameter adjustment value. Further, in some possible embodiments, the memory parameter adjustment value includes a retry number adjustment value and/or a timeout parameter adjustment value, and/or the like.

It can be seen that, the scheme of the present application introduces the memory error handling apparatus 600, so that the interaction between the user mode application and the SCSI protocol stack no longer depends on the unique intermediate bridge of the block device, and a second channel is opened up for the interaction between the user mode application and the SCSI protocol stack, that is, the user mode application can indirectly access the SCSI protocol stack through the memory error handling apparatus, and then access the memory. Therefore, the flexibility of user mode application data access is higher, and the error resistance is favorably improved. In addition, because the block device accesses the SCSI protocol stack using a standard block device access command (e.g., a read/write command), and the SCSI protocol stack usually returns a simple error response (EIO) to the block device when an access error occurs for the access method agreed in the related protocol, and the EIO does not reflect a specific reason for the access error, it is difficult to perform targeted error repair. In the technical scheme of the application, the memory error processing device converts the first user mode data access command from the user mode application into the first SCSI command, and then forwards the first SCSI command to the memory for execution through the SCSI protocol stack, and the SCSI protocol stack can feed back the relevant response carrying the memory error code for the SCSI type access command, so that when an access error occurs, the memory error processing device can obtain the relevant error reason based on the memory error fed back by the SCSI protocol stack, thereby being beneficial to repairing the relevant error in a more targeted way and further being beneficial to improving the stability and reliability of the system.

Referring to fig. 7, an embodiment of the present application provides a memory error handling apparatus 700, including: a memory 710 and a processor 720, wherein the processor 720 is configured to perform the following steps by calling instructions or code stored in the memory:

receiving a first user mode data access command sent by a user mode application; converting the first user-mode data access command into a first Small Computer System Interface (SCSI) command; sending the first SCSI command to the memory through a SCSI protocol stack; when a first response sent by the SCSI protocol is received, the first response indicates that the execution of the first SCSI command fails, the first response carries a memory error code, a second SCSI command for repairing the memory is obtained, and a repairing operation instruction of the second SCSI command corresponds to the memory error code; and sending the second SCSI command to the memory through the SCSI protocol stack.

Further, the memory error handling device 700 may obtain the second SCSI command for repairing the memory in a variety of ways.

Further, in some possible embodiments, the second SCSI command also carries a memory parameter adjustment value, and the second SCSI command is also used to instruct the memory to perform a parameter adjustment based on the memory parameter adjustment value. Further, in some possible embodiments, the memory parameter adjustment value comprises a retry number adjustment value and/or a timeout parameter adjustment value.

It can be seen that the scheme of the present application introduces the memory error handling apparatus 700, so that the interaction between the user mode application and the SCSI protocol stack no longer depends on the unique intermediate bridge of the block device, and a second channel is opened up for the interaction between the user mode application and the SCSI protocol stack, that is, the user mode application can indirectly access the SCSI protocol stack through the memory error handling apparatus, and then access the memory. Therefore, the flexibility of user mode application data access is higher, and the error resistance is favorably improved. In addition, because the block device accesses the SCSI protocol stack using a standard block device access command (e.g., a read/write command), and the SCSI protocol stack usually returns a simple error response (EIO) to the block device when an access error occurs for the access method agreed in the related protocol, and the EIO does not reflect a specific reason for the access error, it is difficult to perform targeted error repair. In the technical scheme of the application, the memory error processing device converts the first user mode data access command from the user mode application into the first SCSI command, and then forwards the first SCSI command to the memory for execution through the SCSI protocol stack, and the SCSI protocol stack can feed back the relevant response carrying the memory error code for the SCSI type access command, so that when an access error occurs, the memory error processing device can obtain the relevant error reason based on the memory error fed back by the SCSI protocol stack, thereby being beneficial to repairing the relevant error in a more targeted way and further being beneficial to improving the stability and reliability of the system.

In the foregoing embodiments, the descriptions of the respective embodiments have respective emphasis, and for parts that are not described in detail in a certain embodiment, reference may be made to related descriptions of other embodiments.

Furthermore, an embodiment of the present application provides a computer-readable storage medium storing program code for session message processing. The program code includes instructions for carrying out some or all of the steps of any of the memory error handling methods of the present application.

In the embodiments provided in the present application, it should be understood that the disclosed apparatus may be implemented in other manners. For example, the above-described embodiments of the apparatus are merely illustrative, and for example, the division of the units is merely a logical division, and the actual implementation may have another division, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted or not executed. In addition, the indirect coupling or direct coupling or communication connection between each other shown or discussed may be through some interfaces, indirect coupling or communication connection of devices or units, and may be electrical or in other forms.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit may be implemented in the form of hardware, or may also be implemented in the form of a software functional unit.

The integrated unit, if implemented in the form of a software functional unit and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application may be substantially implemented or contributed to by the prior art, or all or part of the technical solution may be embodied in a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a removable hard disk, a magnetic disk, or an optical disk, which can store program codes.

Claims

1. A memory error handling method of a computer system, the computer system comprising: a user-mode application, a memory error handling component, and a Small Computer System Interface (SCSI) protocol stack, wherein the memory error handling component and the SCSI protocol stack are located in a kernel mode of the computer system;

the method comprises the following steps: the user-mode application sending a first user-mode data access command to the memory error handling component;

after receiving a first user mode data access command sent by the user mode application, the memory error processing component converts the first user mode data access command into a first SCSI command, and sends the first SCSI command to the memory through a SCSI protocol stack;

the SCSI protocol stack sends the first SCSI command to the storage after receiving the first SCSI command; receiving an execution result of the first SCSI command by the storage, and sending a first response to the storage error processing component when the execution result indicates that the first SCSI command fails to be executed by the storage, wherein the first response indicates that the first SCSI command fails to be executed, and the first response carries a storage error code;

2. The method of claim 1, further comprising: when the second SCSI command is a restart command, the memory is restarted by executing the received second SCSI command; or when the second SCSI command is a reset command, the memory is reset by executing the received second SCSI command; or when the second SCSI command is an access start address adjustment command, the memory adjusts the access start address by executing the received second SCSI command.

3. The method of claim 1, wherein obtaining the second SCSI command to repair the memory comprises: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; and generating a second SCSI command matched with the error processing strategy based on the error processing strategy.

4. The method of claim 2, wherein obtaining the second SCSI command to repair the memory comprises: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; and generating a second SCSI command matched with the error processing strategy based on the error processing strategy.

5. The method of claim 1, wherein obtaining the second SCSI command to repair the memory comprises: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; sending the error handling policy to the user-mode application; receiving the second SCSI command sent by the user-mode application by calling an error handling function matched with the error handling policy.

6. The method of claim 2, wherein obtaining the second SCSI command to repair the memory comprises: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; sending the error handling policy to the user-mode application; receiving the second SCSI command sent by the user-mode application by calling an error handling function matched with the error handling policy.

7. The method of any of claims 3 to 6, wherein the second SCSI command further carries a memory parameter adjustment value, the second SCSI command further instructing the memory to perform a parameter adjustment based on the memory parameter adjustment value.

8. The method of claim 7, wherein the memory parameter adjustment value comprises a retry number adjustment value and/or a timeout parameter adjustment value.

9. The method according to any one of claims 1 to 6, wherein the computer system further comprises a block device corresponding to the memory, wherein the block device is located in a kernel state of the computer system;

before the user-mode application sends the first user-mode data access command to the memory error handling component, the method further comprises:

the SCSI protocol stack converts the received standard block equipment access command into a third SCSI command and sends the third SCSI command to the memory; receiving an execution result of the memory for the third SCSI command; when the execution result of the memory for the third SCSI command is that the execution of the third SCSI command fails, the SCSI protocol stack sends, to the block device, a response indicating that the execution of the standard block device access command fails;

10. The method of claim 7, wherein the computer system further comprises a block device corresponding to the memory, wherein the block device is in a kernel state of the computer system;

11. The method of claim 8, wherein the computer system further comprises a block device corresponding to the memory, wherein the block device is in a kernel state of the computer system;

12. A memory error handling method, comprising:

receiving a first user mode data access command sent by a user mode application;

converting the first user-mode data access command into a first Small Computer System Interface (SCSI) command;

sending the first SCSI command to the memory through a SCSI protocol stack;

when a first response sent by the SCSI protocol stack is received, the first response indicates that the execution of the first SCSI command fails, wherein the first response carries a memory error code, a second SCSI command for repairing the memory is obtained, wherein a repairing operation instruction of the second SCSI command corresponds to the memory error code, and the second SCSI command is sent to the memory through the SCSI protocol stack;

wherein the obtaining a second SCSI command to repair the memory comprises: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; generating a second SCSI command matched with the error processing strategy based on the error processing strategy;

or,

the obtaining and using the second SCSI command to repair the memory comprises: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; sending the error handling policy to the user-mode application; receiving the second SCSI command sent by the user-mode application by calling an error handling function matched with the error handling policy.

13. The method of claim 12, wherein the second SCSI command further carries a memory parameter adjustment value, the second SCSI command further instructing the memory to perform a parameter adjustment based on the memory parameter adjustment value.

14. A computer system, comprising: a user-mode application, a memory error handling component, and a Small Computer System Interface (SCSI) protocol stack, wherein the memory error handling component and the SCSI protocol stack are located in a kernel mode of the computer system;

15. The system of claim 14, wherein the computer system further comprises the memory,

the memory is used for restarting by executing the received second SCSI command when the second SCSI command is a restart command; or when the second SCSI command is a reset command, resetting by executing the received second SCSI command; or when the second SCSI command is an access starting address adjusting command, adjusting the access starting address by executing the received second SCSI command.

16. The system of claim 14, wherein, in obtaining the second SCSI command to repair the memory, the memory error handling component is specifically configured to invoke an error handling plug-in corresponding to a vendor to which the memory belongs to parse the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; and generating a second SCSI command matched with the error processing strategy based on the error processing strategy.

17. The system of claim 15, wherein, in obtaining the second SCSI command to repair the memory, the memory error handling component is specifically configured to invoke an error handling plug-in corresponding to a vendor to which the memory belongs to parse the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; and generating a second SCSI command matched with the error processing strategy based on the error processing strategy.

18. The system of claim 14, wherein, in obtaining the second SCSI command to repair the memory, the memory error handling component is specifically configured to invoke an error handling plug-in corresponding to a vendor to which the memory belongs to parse the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; sending the error handling policy to the user-mode application; receiving the second SCSI command sent by the user-mode application by calling an error handling function matched with the error handling policy.

19. The system of claim 15, wherein, in obtaining the second SCSI command to repair the memory, the memory error handling component is specifically configured to invoke an error handling plug-in corresponding to a vendor to which the memory belongs to parse the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; sending the error handling policy to the user-mode application; receiving the second SCSI command sent by the user-mode application by calling an error handling function matched with the error handling policy.

20. The system of any one of claims 14 to 19, wherein the memory is a Shingled (SMR) hard disk.

21. The system according to any one of claims 14 to 19, wherein the computer system further comprises a block device corresponding to the memory, wherein the block device is located in a kernel state of the computer system;

the SCSI protocol stack is also used for converting the received standard block device access command into a third SCSI command and sending the third SCSI command to the memory; receiving an execution result of the memory for the third SCSI command; when the execution result of the memory for the third SCSI command is failure of executing the third SCSI command, sending a response indicating that the standard block device access command fails to be executed to the block device;

22. The system of claim 20, wherein the computer system further comprises a block device corresponding to the memory, wherein the block device is in a kernel state of the computer system;

23. A memory error handling apparatus, comprising:

a repairing unit, configured to, when a first response sent by the SCSI protocol stack is received, where the first response indicates that the first SCSI command fails to be executed, and the first response carries a memory error code, obtain a second SCSI command for repairing the memory, where a repairing operation indication of the second SCSI command corresponds to the memory error code;

the sending unit is further configured to send the second SCSI command to the storage through the SCSI protocol stack;

in an aspect of obtaining the second SCSI command for repairing the memory, the repairing unit is specifically configured to: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; generating a second SCSI command matched with the error processing strategy based on the error processing strategy;

or,

in terms of obtaining a second SCSI command to repair the memory, the repair unit is specifically configured to: calling an error processing plug-in corresponding to the manufacturer of the memory to analyze the memory error code; receiving an error processing strategy which is sent by the error processing plug-in and corresponds to the memory error code; sending the error handling policy to the user-mode application; receiving the second SCSI command sent by the user-mode application by calling an error handling function matched with the error handling policy.

24. The apparatus of claim 23, wherein the second SCSI command further carries a memory parameter adjustment value, and wherein the second SCSI command is further configured to instruct the memory to perform a parameter adjustment based on the memory parameter adjustment value.