CN1279455C - Fiber Channel - Logical Unit Number Caching Method for Storage Area Network Systems - Google Patents

Abstract

The present invention relates to an LUN CACHE method for an FC-SAN storage subsystem, which belongs to the storage technical field of a storage area network. The LUN CACHE method for an FC-SAN storage subsystem is characterized in that the LUN CACHE method for an FC-SAN storage subsystem is realized by that a logic unit number cache LUN CACHE module runs in an embedded system of I/O processing nodes in the FC-SAN; the LUN CACHE method for an FC-SAN storage subsystem uses an improved CACHE replacement algorithm to enhance the utilization ratio of cache so as to cause read-write operation to be quickly completed in the I/O processing nodes in a buffering mode without being sent to a concrete SCSI apparatus; using delayed write technology causes data update operation to be completed backstage, which enormously enhances a user's response time; using a read-write lock mechanism ensures the consistency of shared data among a plurality of users; a favorable interface device design causes LUN CACHE to be completely transparent to a user. Through test, the read-write operation performance of the present invention is enormously enhanced than not using the LUN CACHE before.

Description

Fiber Channel—Logical Unit Number Caching Method for Storage Area Network Systems

technical field

Fiber channel - logical unit number caching method for storage area network system belongs to the field of storage technology in fiber channel - storage area network

Background technique

In the field of data storage, compared with the improvement of CPU performance and memory capacity according to Moore's Law, as the main device of external storage - hard disk, the performance improvement is very limited due to the nature of mechanical movement. At the same time, the density of disk storage has increased by about 60% per year, which is even higher than the improvement rate of CPU and memory. In view of the continuous expansion of capacity and very limited speed increase, all disks currently have MB-level cache subsystems to improve disk performance. Studies have shown that on-disk cache can greatly improve the read and write performance of the disk.

The LUN CACHE method we proposed is different from the previous technology. Instead of directly handing over the command issued by the user to the disk for execution, the command is cached on the I/O node of FC-SAN and executed according to the buffer strategy. .

Contents of the invention

The purpose of the invention is to improve the response speed of the FC-SAN storage system without reducing the data consistency and reliability. The core of this method is: use the improved Cache replacement algorithm to improve the Cache utilization rate, so that the read and write operations can be completed in the Cache, rather than sent to a specific SCSI device; use the delayed write technology to enable the data update operation to be completed in the background, It greatly improves the user's response time; uses the read-write lock mechanism to ensure the consistency of shared data among multiple users; and a good interface design makes LUN CACHE completely transparent to users.

The present invention is characterized in that: it is a high-speed cache method based on the logical unit number LUN running on the I/O processing node under a fiber channel-storage area network FC-SAN environment, and it is run on the FC by the LUN CACHE module. -Implemented on the embedded operating system of the I/O processing node in the SAN, the structure of the LUN CACHE module is as follows:

Interface sub-module: it is an interface for simulating a small computer system, and an interface with the SCSI target simulator middle layer STML and the I/O subsystem. It is equipped with:

(1) The interface with the STML module of the middle layer of the SCSI target simulator is realized by registering the data structure Scsi_Target_Template defined by the STML module.

(2) The interface with the I/O subsystem is realized by calling the scsi_do_req function in the I/O subsystem.

Shared lock sub-module: There are two types of logical unit number LUN read-write locks as follows:

(1) Public READER-WRITER LOCK: BUFFER LOCK, that is, LUN read-write lock; it is a kind of when the interface sub-module obtains the SCSI command from the STML module, before forwarding it to the buffer management sub-module, it must first obtain the SCSI command from the shared lock sub-module Obtained logical unit number LUN read-write lock, otherwise it will enter the waiting state.

(2) The READER-WRITER LOCK set for each fixed-size data block, that is, the I/O read-write lock, is an actual physical lock when the buffer management submodule sends the SCSI command to the I/O subsystem. Before disk access, the I/O read-write lock obtained from the shared lock submodule must first be obtained, otherwise it will also enter the waiting state.

The LUN read-write lock corresponding to different logical unit numbers is expressed as LUN id, and the read-write lock is obtained by using the read-write lock algorithm.

Buffer management submodule: it creates a hash table for each logical unit number LUN, and saves the data involved in the SCSI commands distributed by all STML modules in the buffer of the LUN CACHE, and it accepts SCSI commands from the STML module , to read and write data from the buffer or the I/O subsystem.

Data synchronization sub-module: It updates the content of the buffer according to the frequency of user access, and at the same time updates the data in the buffer to the disk system.

The update of the buffer data is implemented by using the latest and longest unused algorithm after each actual I/O read and write operation of the LUN CACHE.

The update of the disk system data also regularly updates the buffer data to the disk system in the background after each LUN CACHE performs buffer read and write operations.

Initialization and exit sub-module: It performs startup work when LUN CACHE is loaded, exits work when unloaded, and applies for and initializes the memory data structure at the same time.

The LUN CACHE module containing the above submodules runs on the embedded operating system of the I/O processing node in the following steps:

(1) SCSI target emulator middle layer STML sends SCSI operation to the interface sub-module;

(2) After the interface submodule obtains the SCSI command from STML, before forwarding it to the buffer management submodule, it applies for the LUN read-write lock from the shared lock submodule. If it obtains the LUN read-write lock from the shared lock submodule, it applies to the buffer The zone management sub-module sends SCSI commands, otherwise it goes into a waiting state.

(3) The buffer management submodule receives the SCSI command from STML, first obtains the address of the command read and write data from the SCSI command, and then performs a buffer search operation according to the address, if the data required by the command is in the buffer, then Read and write data directly in the buffer. After reading and writing, the data result is returned to the middle layer STML of the SCSI target simulator. At the same time, the data synchronization sub-module updates the data in the buffer to the disk system according to the specified time interval; if the required data cannot be found in the buffer data, perform the following steps.

(4) The buffer sub-module applies for the I/O read-write lock from the shared lock sub-module, if the I/O read-write lock cannot be obtained from the shared lock sub-module, it enters the waiting state; otherwise, the following steps are performed.

(5) The buffer management sub-module applies for the I/O read-write lock, and then transmits the SCSI command to the I/O subsystem through the interface sub-module and obtains the data. After the data is read and written, the result data is returned to the SCSI target simulation STML in the middle layer of the device; at the same time, the data synchronization sub-module uses the latest and longest unused algorithm to update the data in the buffer.

(6) END.

The read-write lock algorithm is realized through READER-WRITER locks of different granularities: the data structure of the READER-WRITER lock is:

struct RWLock{

struct semaphore rw_sem;//semaphore

spinlock_t rw_spin_lock;//shared lock

int flag; //LUN read-write lock or I/O read-write lock bit

Target_Scsi_Cmnd*cmnd; //SCSI command

unsigned int bgblock;//start length of data segment

unsigned int length;//data segment length

}

The latest algorithm that has not been used for the longest time, it sets an access count and access time mark for each data block of the buffer and each logical unit number LUN, and each data operation will update the corresponding access count and access Time stamp, when the buffer needs to be updated, it selects the data block with the least number of visits from the buffer and the logical unit number with the least number of visits from the buffer and deletes it.

The test proves that the performance of write operation is increased by about 4 times, and the performance of read operation increases with the increase of load. After reaching a certain level, it is close to the system without CACHE.

Description of drawings

Figure 1. The hardware subsystem architecture of a massive network storage device, Myrinet is a high-speed interconnection technology.

Figure 2. I/O node hardware subsystem module structure

Figure 3. Schematic diagram of the module structure of the mass storage system. Among them, STML is a software-based SCSI command and task processing module that can dynamically adjust performance.

Figure 4. Schematic diagram of the module structure of LUN CACHE.

Figure 5. LUN CACHE system program flow chart.

Figure 6. Comparison of read operation performance with and without LUN CACHE.

Figure 7. Comparison of write performance with and without LUN CACHE.

Detailed ways

The hardware environment of the present invention is Tsinghua University massive network storage device (abbreviated as TH-MNSM), which specifically runs on the I/O processing node of TH-MNSM. The hardware structure of Tsinghua University's massive network storage device is shown in Figure 1.

It mainly includes the following components:

(1) Host node (HNODE)

The control center is used for monitoring, backup and other management of the system. The hardware subsystem of the host node includes INTEL CPU, standard PCI bus, SCSI interface card, standard Ethernet interface card (HBA), Myrinet interface card, and hard disk. The host node can run various operating systems such as WINDOWS 2000 and WEB server software systems.

(2) I/O processing node (INODE)

The most basic and important part of massive network storage devices. The main functions include data storage, fiber channel protocol processing, and SCSI protocol processing. The I/O processing node is composed of 2-4 INTEL XEON processors, 512M memory, motherboard based on PCI bus, Myrinet interface card, FLASH DISK, fiber channel interface card, SCSI interface card, and has high performance.

(3) High-density disk array (HARRAY)

Each I/O node uses a standard SCSI card to directly connect to current commercial disk arrays. Each I/O node can connect up to 8 disk arrays, and supports a maximum capacity of 150TB.

(4) Internet based on Myrinet

It is a system interconnection component that connects I/O processing nodes and host nodes. The Myrinet-based interconnection network replaces the high-speed backplane in the traditional design. This method has the advantages of economy and reliability.

(5) Power subsystem

Commercialized power supply using N+1 mode.

The host node adopts a commercial commercial PC such as Lenovo Tianrui 3130, so its structure is the same as that of a PC. The module structure of the hardware subsystem of each I/O processing node is shown in FIG. 2 .

The motherboard of each I/O node adopts commercial server motherboards such as Supermicro X5DA8 and X5DAE motherboards, and all CPUs use INTEL XEON series CPUs. Each I/O node includes two commercial fiber channel HBAs, such as the QLA2310F series of QLOGIC, which can implement fault-tolerant backup or bundle functions between them. Each I/O node includes 2-3 commercial SCSI interface cards, such as ADAPTEC's 7XXX series interface cards, which are connected to high-density disk array subsystems such as ISD PinnacleRAID 500. The power supply subsystem adopts the current standard and commercial N+1 power supply, such as the 3C3 series of Santak, and the FLASH DISK is responsible for storing various software, such as the DOC2000 series of M-SYSTEMS. Myrinet interface card adopts LANai9 series interface card of Myricom Company.

LUN CACHE runs on the embedded operating system of the I/O processing node in the massive network storage. The software structure diagram of the massive network storage and the I/O logical position of the LUN CACHE are shown in Figure 3.

According to the position of LUN CACHE in the software structure of massive network storage, combined with the system structure characteristics of embedded operating system of massive network storage, we designed the software structure of LUN CACHE. As shown in Figure 4, the software structure of LUN CACHE includes: buffer management submodule, shared lock submodule, data synchronization submodule, interface submodule, initialization and exit submodule. The structure and functions of specific modules are detailed as follows:

The interface submodule is divided into two parts:

(1) The interface with the middle layer of the SCSI target device.

(2) Interface with I/O subsystem.

The purpose of the interface sub-module is to ensure that the LUN CACHE system does not affect the I/O path of the entire FC-SAN, so that LUNCACHE is transparent to users and does not affect the normal operation of user programs. In FC-SAN without LUN CACHE, the SCSI target middle layer interacts with the I/O subsystem, so the main function of the interface submodule in LUN CACHE is to simulate the connection between the SCSI target middle layer and the I/O subsystem. interface.

The interface with the SCSI target is realized by registering the data structure Scsi_Target_Template defined by the SCSI target:

#define ISP_TARGET{\

name: "ISP", \

detect:isp_detect, \

release:isp_release, \

xmit_response:isp_xmit_response, \

rdy_to_xfer:isp_rdy_to_xfer, \

task_mgmt_fn_done:isp_task_mgmt_done, \

report_aen:isp_report_aen \

}

Scsi_Target_Template my_template = ISP_TARGET;

The interface with the I/O subsystem is implemented by calling the scsi_do_req function, which is provided by the I/O subsystem:

void scsi_do_req(Scsi_Request*SRpnt, const void*cmnd, void*buffer, unsigned bufflen, void(*done)(Scsi_Cmnd*), int timeout, int retries)

Among them, Scsi_Request is a data structure defined by Linux, which is used to store SCSI commands, buffer is the data area filled in the return value, bufflen indicates the length of valid data in the data area, and the done function is the return function. When the I/O subsystem finishes processing the After the SCSI command, call the done function to return to the LUN CACHE system.

FC-SAN is a storage device shared by multiple users. After adding LUN CACHE, users not only share the disk system, but also share the Cache system at the same time. In order for the system to work normally, the consistency of user data must be guaranteed. To this end, we propose a read-write lock mechanism, which is different from other shared lock mechanisms such as the DLOCK mechanism in Sistina's GFS. Our read-write lock does not require users to add new SCSI commands. DLOCK also has the problem of SPIN-LOCK, and has good scalability.

When the interface sub-module gets the SCSI command from STML and forwards it to the buffer management sub-module, it must first obtain the LUN read-write lock from the shared lock sub-module, otherwise it will enter the waiting state. Before the buffer management submodule sends the SCSI command to the I/O subsystem for actual physical disk access, it must first obtain the I/O read-write lock from the shared lock submodule, otherwise it will also enter the waiting state. The algorithm for obtaining a read-write lock is shown in Algorithm A, which will be described in detail below.

Since the buffer operations of the buffer management submodule are mainly memory operations, the speed is relatively fast, while the actual physical disk access operations are relatively slow, so we use different granularities for LUN read-write locks and I/O read-write locks Level of shared lock control. For LUN read-write lock, we use a common READER-WRITER LOCK: BUFFER LOCK to control; for I/O read-write lock, we set a READER-WRITER for each fixed-size data block (the default value is 16M). LOCK.

Since the disk space between each LUN of FC-SAN is independent, there will be no read-write related operations between each LUN. Combining this feature, we further refine the read-write lock and add Adding the LUN id attribute speeds up the judgment of read-write lock mutual exclusion.

Algorithm A Read-write lock algorithm

The core of this algorithm is to provide a mutual exclusion mechanism for buffer operations and I/O operations through READER-WRITER locks of different granularities, and combine LUNs to determine whether the locks are mutually exclusive.

Because the buffer operation speed is fast, a single READER-WRITER lock is used to reduce the time consumption of accessing the lock; while the I/O operation is relatively slow, the time of accessing the lock can be ignored compared with it, so for Each data block establishes a READER-WRITER lock.

For READER-WRITER locks, there are the following principles: any lock supports multiple SCSI commands to read at the same time, and a lock only has one SCSI command for online writing. But each lock allows multiple read and write SCSI commands to wait for execution. If there are multiple SCSI waiting commands, the write command has priority over any read command.

Since the disk space between LUNs in FC-SAN is independent, the READER-WRITER locks between different LUNs are also completely independent, that is, different LUNs correspond to different lock spaces, and there is no interaction between them.

In terms of specific implementation, the algorithm maintains an array of READER-WRITER locks. According to the above-mentioned READER-WRITER lock principle, it is determined whether a SCSI command obtains the corresponding read-write lock. The next operation can only be performed until the write lock is obtained.

In actual operation, this algorithm well guarantees the uniqueness of user data, and the READER-WRITER lock ensures that read operations can be executed in parallel as much as possible, improving system performance.

The buffer management sub-module is the core of the entire LUN CACHE, and the data involved in SCSI commands distributed by all STML modules can be stored in the buffer of the LUN CACHE according to specific management strategies.

The buffer management submodule accepts the SCSI command from the interface submodule, first obtains the address of the command to read and write data from the SCSI command, and then performs a buffer search operation according to the address. If the data required by the command is in the buffer, directly Read and write data in the buffer, otherwise forward the SCSI command to the I/O subsystem.

In order to speed up the search process of the buffer, the buffer is organized using a hash table. At the same time, considering the fact that the disk space between different LUNs of FC-SAN is independent of each other, a hash table is established for each LUN for different LUNs, so that Greatly increased the speed of finding buffers.

The purpose of the data synchronization sub-module is to update the content of the buffer according to the frequency of user access, so that LUN CACHE can ensure a high cache hit rate; at the same time, the data in the buffer is updated to the disk system regularly to ensure the consistency of user data sex.

After each actual I/O read and write operation, the LUN CACHE must update the buffer according to the algorithm that has not been used for the most recent time. For a detailed description of the algorithm that has not been used for the longest time, see Algorithm B, which will be described in detail below.

Every time LUN CACHE reads and writes the buffer, the data in the buffer will be inconsistent with the data on the actual disk. Therefore, it is necessary to periodically update the data in the buffer to the disk system in the background. If the fixed time interval has It is realized that regardless of the size of the specific data volume, the disk write operation must be performed, so that the data consistency can be better maintained. Since the update operation is run using a background thread, it will not affect the performance of the I/O node machine.

Algorithm B The least recently used algorithm

The core of this algorithm is to determine whether to keep the data block in the buffer by counting the access times of the data block in the buffer and combining the access frequency of the LUN to which the block belongs.

According to statistics, most of the user's general I/O operations are continuous read and write operations, and the probability of a data block being accessed by similar I/O operations is relatively high. Therefore, if a data block has not been accessed for a long time, in order to improve the buffer utilization, the data block can be deleted from the buffer and replaced with the most recently accessed data block.

In FC-SAN, the disk space between different LUNs is independent. Due to the continuity of user access to data, the possibility of consecutive access to the same LUN is greater than the possibility of access to different LUNs. Therefore, we consider LUM information when deciding whether to delete a data block. If a LUN appears more times in recent accesses, the data blocks belonging to this LUN will be retained.

In terms of specific implementation, the algorithm maintains an access count and time stamp for each data block in the buffer and each LUN, and each data operation will update the corresponding access count and time stamp. When the buffer needs to be updated, the algorithm selects from the buffer the data block with the least number of accesses and the LUN with the least number of accesses within the current period of time and deletes it.

This algorithm can well guarantee the hit rate of the data in the buffer, so that most of the user's operations can be executed in the buffer, thus effectively reducing the response time of the system.

The main task of initializing and exiting submodules is to perform startup work when LUN CACHE is loaded, and to perform exit work when unloading. The specific tasks performed include:

(1) Execute the functions that must be executed when the embedded system loads/unloads modules.

(2) Apply for and initialize the memory data structure.

(3) Execute the functions necessary for the interface between the LUN CACHE module and the STML module and the I/O subsystem.

The program flow chart of the LUN CACHE method is shown in Figure 5.

This system has been realized by programming in c language, and it can run on the Linux operating system on the PC. A running example is given below to illustrate the execution process of the system.

Example one:

First, the system starts and loads the LUN CACHE system.

1. The user issues a read command M1. After the STML module receives the read command, it transmits the command M1 to the system through the interface sub-module.

2. The system applies for a LUM read-write lock, successfully obtains the read-write lock, and then enters the buffer management sub-module.

3. The buffer management submodule searches the buffer and finds that the buffer does not have the data required by M1.

4. Release the LUN read-write lock and apply for an I/O read-write lock.

5. The application for the I/O read-write lock fails and enters the waiting queue.

6. After waiting for M1 to obtain the I/O read-write lock, transfer M1 to the underlying I/O subsystem through the interface function for actual I/O read-write lock.

7. The underlying I/O subsystem returns the result data of M1 to the LUN CACHE system through the interface function.

8. Release the I/O read-write lock, and return the result data of M1 to the STML module through the interface sub-module.

9. The data synchronization sub-module regularly updates the buffer according to the algorithm that has not been used for the longest time.

Example two:

First, the system starts and loads the LUN CACHE system.

1. The user issues a write command M2. After receiving the write command, STML passes the command M2 to the system through the interface sub-module.

2. The system applies for a LUN read-write lock, but the application is unsuccessful and waits.

3. The shared lock submodule notifies M2 to obtain the LUN read-write lock.

4. The buffer management submodule searches the buffer and finds that the buffer has the data required by M2.

5. Write M2 data directly into the buffer. (execute command M2)

6. Release the LUN read-write lock, and return the result of M2 to the STML module through the interface sub-module.

7. The data synchronization sub-module regularly updates the buffer according to the least recently used algorithm.

We conducted performance tests on the user's write and read operations on the mass storage system of Tsinghua University. The test environment is as follows: the user is a 32-bit Itanium dual-CPU server, the CPU frequency is 2.4G, the user's operating system is Linux (Kernel2.4.18-3), and the TH-MNSM mass storage system is connected.

read performance

The test results are shown in Figure 6. The vertical axis in the figure represents the response time in ms, and the horizontal axis represents the size of the I/O request. Tests were obtained under intensive load conditions. Shown are the read performance of TH-MNSM system using LUN CACHE and TH-MNSM system without LUN CACHE respectively. As can be seen from the figure, as the load increases, the read performance increases. Of course, after the load increases to a certain extent, the role of CACHE gradually decreases, and the system read performance tends to be that of the system without CACHE.

write performance

The test results are shown in Figure 7. The vertical axis in the figure represents the response time in ms, and the horizontal axis represents the size of the I/O request in KB. It can be seen from the figure that the existence of LUN CACHE greatly improves the performance of system writing, because LUN CACHE always buffers write operations in the buffer as much as possible, and then updates data through background threads. The data in the figure shows that the performance improvement is about 4 times.

Main features of the present invention are as follows:

(1) Combined with the architectural characteristics of the mass storage system, an improved cache replacement strategy is adopted to improve the actual utilization of the cache and reduce the actual I/O operations.

(2) Design read-write locks of different granularities and algorithms for applying for read-write locks. While ensuring the consistency of user data, it fully improves the concurrency of I/O operations and maximizes data read and write performance.

(3) Good interface design makes the whole system completely transparent to users.

(4) It can be realized without adding any new hardware on the basis of TH-MSNM, which saves the cost.

Claims (3)

1. The logical unit number cache method of the fiber channel-storage area network system, which contains the cache cache method, is characterized in that: it is a fiber channel-storage area network FC-SAN environment and runs on the I/O processing node The logical unit number LUN-based cache CACHE method is implemented by the LUN CACHE module running on the embedded operating system of the I/O processing node in FC-SAN. The structure of the LUN CACHE module is as follows: Interface sub-module: it is an interface for simulating a small computer system, an interface with the SCSI target simulator middle layer STML and the I/O subsystem, and it is equipped with: (1) The interface with the STML module of the middle layer of the SCSI target simulator is realized by registering the data structure Scsi_Target_Template defined by the STML module; (2) The interface with the I/O subsystem is realized by calling the scsi_do_req function in the I/O subsystem; Shared lock sub-module: There are two types of logical unit number LUN read-write locks as follows: (1) Public READER-WRITER LOCK: BUFFER LOCK, that is, LUN read-write lock; it is a kind of when the interface sub-module obtains the SCSI command from the STML module, before forwarding it to the buffer management sub-module, it must first obtain the SCSI command from the shared lock sub-module Obtained logical unit number LUN read-write lock, otherwise it will enter the waiting state; (2) The READER-WRITER LOCK set for each fixed-size data block, that is, the I/O read-write lock, is an actual physical lock when the buffer management submodule sends the SCSI command to the I/O subsystem. Before disk access, the I/O read-write lock obtained from the shared lock sub-module must first be obtained, otherwise it will also enter the waiting state; Corresponding to different logical unit numbers, the LUN read-write lock is represented as LUN id, and the read-write lock is obtained by using the read-write lock algorithm; Buffer management submodule: it creates a hash table for each logical unit number LUN, and saves the data involved in the SCSI commands distributed by all STML modules in the buffer of the LUN CACHE, and it accepts SCSI commands from the STML module , read and write data from the buffer or I/O subsystem; Data synchronization sub-module: It updates the content of the buffer according to the frequency of user access, and at the same time updates the data in the buffer to the disk system; The update of buffer data is realized by using the latest and longest unused algorithm after each actual I/O read and write operation of LUN CACHE; The update of the disk system data also regularly updates the buffer data to the disk system in the background after each LUN CACHE performs a buffer read and write operation; Initialization and exit sub-module: It starts the work when the LUN CACHE is loaded, exits the work when it is unloaded, and applies for and initializes the memory data structure at the same time; The LUN CACHE module containing the above submodules runs on the embedded operating system of the I/O processing node in the following steps: (1) SCSI target emulator middle layer STML sends SCSI operation to the interface sub-module; (2) After the interface submodule obtains the SCSI command from STML, before forwarding it to the buffer management submodule, it applies for the LUN read-write lock from the shared lock submodule. If it obtains the LUN read-write lock from the shared lock submodule, it applies to the buffer The zone management sub-module sends the SCSI command, otherwise it turns to the waiting state; (3) The buffer management submodule receives the SCSI command from STML, first obtains the address of the command read and write data from the SCSI command, and then performs a buffer search operation according to the address, if the data required by the command is in the buffer, then Read and write data directly in the buffer; after reading and writing, return the data result to the middle layer STML of the SCSI target simulator, and at the same time, the data synchronization sub-module updates the data in the buffer to the disk system according to the specified time interval; if If the required data cannot be found in the buffer, perform the following steps; (4) The buffer submodule applies for the I/O read-write lock from the shared lock submodule, if the I/O read-write lock cannot be obtained from the shared lock submodule, it will enter the waiting state; otherwise, the following steps are performed: (5) The buffer management sub-module applies for the I/O read-write lock, and then transmits the SCSI command to the I/O subsystem through the interface sub-module and obtains the data. After the data is read and written, the result data is returned to the SCSI target simulation STML in the middle layer of the device; at the same time, the data synchronization sub-module uses the latest and longest unused algorithm to update the data in the buffer; (6) END. 2. The logical unit number cache method of the Fiber Channel-Storage Area Network system according to claim 1, characterized in that: the read-write lock algorithm, it is through the READER-WRITER described in claim 1 of different granularity LOCK is implemented: the data contained in READER-WRITER LOCK are: semaphore, shared lock, the flag bit used to indicate whether it is a LUN read-write lock or an I/O read-write lock, SCSI command, the start address of the data segment, data The length of the segment. 3. The logical unit number caching method of the fiber channel-storage area network system according to claim 1, characterized in that: the latest and longest unused algorithm, which is each data block and each Each logical unit number LUN is set with an access count and an access time stamp. Each data operation will update the corresponding access count and access time stamp. When the buffer needs to be updated, it selects from the buffer within a certain period of time. The data block with the least access times and the logical unit number with the least access times is deleted.

Images