Transaction log layout for efficient reclamation and recovery

Abstract

A layout of a transaction log enables efficient logging of metadata into entries of the log, as well as efficient reclamation and recovery of the log entries by a volume layer of a storage input/output (I/O) stack executing on one or more nodes of a cluster. The transaction log is illustratively a two stage, append-only logging structure, wherein the first level is non-volatile random access memory (NVRAM) embodied as a NV log and the second stage is disk, e.g., solid state drive (SSD). The layout of the logging structure facilitates steady-state logging of metadata managed by the volume layer and crash recovery. Steady-state logging of metadata into the log entries occurs while the storage I/O stack of a node actively processes I/O requests, while crash recovery of the log entries occurs after an unexpected shutdown of the node.

What is claimed is: 
     
         1 . A method comprising:
 receiving at a storage system an input/output (I/O) request, wherein the storage system includes a persistent memory coupled to central processor (CPU) and one or more storage devices;   associating a first transaction with the I/O request;   allocating a first quota pool from the persistent memory to a first finite state machine (FSM) for processing the first transaction, the first quota pool including a circular log;   logging a start entry in the circular log;   in response to processing the first transaction, generating one or more entries to the circular log;   determining whether the generated one or more log entries exceed a high watermark of the persistent memory;   in response to determining that the one or more log entries do not exceed the high watermark, logging an end entry in the circular log; and   reclaiming the generated one or more log entries in the circular log.   
     
     
         2 . The method of  claim 1  further comprising:
 in response to determining that the generated one or more log entries exceed the high watermark of the persistent memory, suspending processing of the first transaction by the first FSM. 
 
     
     
         3 . The method of  claim 1  further comprising:
 processing a second transaction by a second FSM concurrently with the processing of the first transaction by the first FSM; and 
 allocating a second quota pool to the second FSM from the persistent memory, wherein the second quota pool is different from the first quota pool, and wherein the concurrent processing is lockless. 
 
     
     
         4 . The method of  claim 2  wherein the circular log appears as a continuous log to the first FSM. 
     
     
         5 . The method of  claim 4  wherein reclaiming further comprises:
 reclaiming sufficient log entries from the persistent memory to reach a low watermark of the persistent memory; and 
 resuming processing of the first transaction by the first FSM. 
 
     
     
         6 . The method of  claim 1  further comprising:
 grouping the first transaction according to an indivisible class of operation; and 
 processing only transactions of the indivisible class of operation by the first FSM. 
 
     
     
         7 . The method of  claim 1  wherein the persistent memory is one of a non-volatile random access memory and a solid state drive. 
     
     
         8 . The method of  claim 3  further comprising:
 de-staging the one or more generated log entries to the one or more storage devices. 
 
     
     
         9 . The method of  claim 3  further comprising:
 executing a first uniprocessor (UP) service to process the first FSM; 
 executing a second UP service to process the second FSM; 
 assigning the first UP to a first core of the CPU; and 
 assigning the second UP service to a second core of the CPU that is different from the first core of the CPU. 
 
     
     
         10 . The method of  claim 2  further comprising:
 determining a size of the first quota pool based on an expected total size of the one or more generated log entries by the first FSM. 
 
     
     
         11 . A system comprising:
 a storage array having one or more storage devices;   a node having a central processor (CPU) connected to a memory, a persistent memory and the storage array, the CPU configured to execute one or more processes stored in the memory, the one or more processes when executed operable:
 receive an input/output (I/O) request and associate a first transaction with the I/O request; 
 allocate a first quota pool from the persistent memory to a first finite state machine (FSM) for processing the first transaction, the first quota pool including a circular log; 
 log a start entry in the circular log; 
 in response to processing the first transaction, generate one or more entries to the circular log; 
 determine whether the generated one or more log entries exceed a high watermark of the persistent memory; 
 in response to determining that the one or more log entries do not exceed the high watermark, log an end entry in the circular log; and 
 reclaim the generated one or more log entries in the circular log. 
   
     
     
         12 . The system of the  claim 11  wherein the one or more processes when executed is further operable to:
 in response to determining that the generated one or more log entries exceed the high watermark of the persistent memory, suspend processing of the first transaction by the first FSM. 
 
     
     
         13 . The system of  claim 11  wherein one or more processes when executed is further operable to:
 process a second transaction by a second FSM concurrently with the processing of the first transaction by the first FSM; and 
 allocate a second quota pool from the persistent memory to the second FSM, wherein the second quota pool is different from the first quota pool, and wherein the concurrent processing is lockless. 
 
     
     
         14 . The system of  claim 12  wherein the circular log appears as a continuous log to the first FSM. 
     
     
         15 . The system of  claim 14  wherein the one or more processes when executed to reclaim is further operable to:
 reclaim sufficient log entries from the persistent memory to reach a low watermark of the persistent memory; and 
 resume processing of the first transaction by the first FSM. 
 
     
     
         16 . The system of  claim 11  wherein the one or more processes when executed is further operable to:
 group the first transaction according to an indivisible class of operation; and 
 process only transactions of the indivisible class of operation by the first FSM. 
 
     
     
         17 . The system of  claim 11  wherein the persistent memory is one of a non-volatile random access memory and a solid state drive. 
     
     
         18 . The system of  claim 13  wherein the one or more processes when executed is further operable to:
 de-stage the one or more generated log entries to the one or more storage devices. 
 
     
     
         19 . The system of  claim 13  wherein a first uniprocessor (UP) service executes the first FSM and a second uniprocessor service executes the second FSM, and wherein the first UP is assigned to first core of the CPU different from a second core of the CPU assigned to the second UP service. 
     
     
         20 . A non-transitory computer readable medium including program instructions for execution on one or more processors, the program instructions when executed operable to:
 implement a storage input/output (I/O) stack that operates with a persistent memory coupled to the one or more processors and with one or more solid state drives (SSDs);   receive an I/O request and associate a transaction with the I/O request;   allocate a first quota pool from the persistent memory to a first finite state machine (FSM) for processing the transaction, the first quota pool including a circular log;   in response to processing the transaction, generate one or more entries to the circular log;   determine whether the generated one or more log entries exceed a high watermark of the persistent memory;   in response to determining that the one or more log entries exceed the high watermark, suspend processing of the transaction by the first FSM;   reclaim other log entries from a second quota pool allocated from the persistent memory to reach a low watermark of the persistent memory; and   in response to reaching the low watermark, resume processing of the transaction by the first FSM.