// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stdarg.h>
#include <string.h>

#include "ftlnp.h"

// Local Function Definitions

//  format_ftl: Erase all non-free blocks
//
//       Input: ftl = pointer to FTL control block
//
//     Returns: 0 on success, -1 on error
//
static int format_ftl(FTLN ftl) {
    ui32 meta_block;

    // Get number of block that will hold the metapage.
    if (ftl->free_mpn == (ui32)-1)
        meta_block = FtlnLoWcFreeBlk(ftl);
    else
        meta_block = ftl->free_mpn / ftl->pgs_per_blk;

    // Write meta page, to indicate that format is in progress.
    memset(ftl->main_buf, 0xFF, ftl->page_size);
    if (FtlnMetaWr(ftl, CONT_FORMAT))
        return -1;

    // Erase all map blocks, mark all blocks free, and reset the FTL.
    return FtlnFormat(ftl, meta_block);
}

// set_high_wc: Set highest wear count and adjust wear offsets
//
//      Inputs: ftl = pointer to FTL control block
//              high_b = block with new highest wear count
//              high_b_wc = new highest wear count
//
static void set_high_wc(FTLN ftl, ui32 high_b, ui32 high_b_wc) {
    ui32 b;

    // Highest wear count should only go up by one and new highest block
    // should have contained highest wear (0 'high_wc' lag) before.
    PfAssert(ftl->high_wc + 1 == high_b_wc && ftl->blk_wc_lag[high_b] == 0);

    // Loop over all other blocks adjusting their 'high_wc' lags.
    for (b = 0; b < ftl->num_blks; ++b)
        if (b != high_b) {
            if (ftl->blk_wc_lag[b] < 0xFF)
                ++ftl->blk_wc_lag[b];
#if FTLN_DEBUG
            else
                ++ftl->max_wc_over;

            // If new value, record maximum encountered wear lag.
            if (ftl->max_wc_lag < ftl->blk_wc_lag[b])
                ftl->max_wc_lag = ftl->blk_wc_lag[b];
#endif
        }

    // Update highest wear count.
    ftl->high_wc = high_b_wc;
}

// first_free_blk: Find the first free block, counting from block zero
//
//       Input: ftl = pointer to FTL control block
//
//     Returns: block number if successful, else (ui32)-1 if none free
//
static ui32 first_free_blk(CFTLN ftl) {
    ui32 b;

    // Search for first free block.
    for (b = 0;; ++b) {
        // Return error if no block is free.
        if (b == ftl->num_blks)
            return (ui32)FsError2(FTL_NO_FREE_BLK, ENOSPC);

        // If block is free, return its block number.
        if (IS_FREE(ftl->bdata[b]))
            return b;
    }
}

// Global Function Definitions

// FtlnReport: Callback function used by upper file system layer to
//              notify FTL of events
//
//      Inputs: vol = FTL handle
//              msg = event
//              ... = additional arguments
//
//     Returns: 0 or 1 (unformat()) for success, -1 on failure
//
int FtlnReport(void* vol, ui32 msg, ...) {
    FTLN ftl = vol;
    va_list ap;

    // Set errno and return -1 if fatal I/O error occurred.
    if (ftl->flags & FTLN_FATAL_ERR)
        return FsError2(NDM_EIO, EIO);

    // Handle event passed down from file system layer.
    switch (msg) {
        case FS_UNFORMAT: {
            ui32 b;

            // Return error if volume is mounted.
            if (ftl->flags & FTLN_MOUNTED)
                return FsError2(FTL_MOUNTED, EEXIST);

            // Format volume. Return -1 if error.
            if (format_ftl(ftl))
                return -1;

            // Erase every unerased block. Return -1 if error.
            for (b = 0; b < ftl->num_blks; ++b)
                if ((ftl->bdata[b] & ERASED_BLK_FLAG) == FALSE)
                    if (FtlnEraseBlk(ftl, b))
                        return -1;

            // Delete volume (both FTL and FS). Free its memory. Volume is
            // unmounted, so nothing to flush. Return value can be ignored.
            FtlnDelVol(ftl);

            // Return '1' for success.
            return 1;
        }

        case FS_FORMAT:
        case FS_FORMAT_RESET_WC: {
            // Format volume. Return -1 if error.
            if (format_ftl(ftl))
                return -1;

            // Check if we're to equalize the wear counts (for benchmarking).
            if (msg == FS_FORMAT_RESET_WC) {
                ui32 b, avg_lag = 0;

                // Compute average wear count and assign to every block.
                for (b = 0; b < ftl->num_blks; ++b) avg_lag += ftl->blk_wc_lag[b];
                avg_lag /= ftl->num_blks;
                ftl->high_wc -= avg_lag;
                for (b = 0; b < ftl->num_blks; ++b) ftl->blk_wc_lag[b] = 0;
            }

            // Return success.
            return 0;
        }

        case FS_VCLEAN:
            return FtlnVclean(ftl);

        case FS_UNMOUNT:
            // Return error if not mounted.
            if ((ftl->flags & FTLN_MOUNTED) == FALSE)
                return FsError2(FTL_UNMOUNTED, ENOENT);

            // Clear the 'mounted' flag.
            ftl->flags &= ~FTLN_MOUNTED;
        // FALLTHROUGH

        case FS_SYNC: {
            // Prepare to write all dirty map cache pages. Return -1 if err.
            if (FtlnRecCheck(ftl, 0))
                return -1;

            // Save all dirty map pages to flash. Return -1 if error.
            if (ftlmcFlushMap(ftl->map_cache))
                return -1;
            PfAssert(ftl->num_free_blks >= FTLN_MIN_FREE_BLKS);

#if INC_FTL_NDM_MLC
            // For MLC devices, advance free_vpn pointer so next volume page
            // write can't corrupt previously written valid page.
            FtlnMlcSafeFreeVpn(ftl);
#endif

            // If request was for sync, return success now.
            if (msg == FS_SYNC)
                return 0;

#if INC_ELIST
            // Check if there is not a current erased-block list.
            if (ftl->elist_blk == (ui32)-1) {
                ui32 b, n;

                // Count the number of erased free blocks.
                for (n = b = 0; b < ftl->num_blks; ++b)
                    if (IS_ERASED(ftl->bdata[b]))
                        ++n;

                // Only write erased list if more than 1 block is erased.
                if (n > 1) {
                    ui32 wc, *lp, prior_free_mpn;
                    ui32* end = (ui32*)(ftl->main_buf + ftl->page_size);

                    // Save free map page number and force elist writes to begin
                    // on first page of a free map block.
                    prior_free_mpn = ftl->free_mpn;
                    ftl->free_mpn = (ui32)-1;

                    // Set pointer to write first entry on page.
                    lp = (ui32*)(ftl->main_buf + FTLN_META_DATA_BEG);

                    // Loop to find erased free blocks.
                    for (b = 0;;) {
                        if (IS_ERASED(ftl->bdata[b])) {
#if DEBUG_ELIST
                            // Verify that this block is unwritten.
                            FtlnCheckBlank(ftl, b);
#endif

                            // Write block number and wear count of erased block.
                            WR32_LE(b, lp);
                            ++lp;
                            wc = ftl->high_wc - ftl->blk_wc_lag[b];
                            WR32_LE(wc, lp);
                            ++lp;

                            // If all blocks recorded, fill rest of page with -1.
                            if (--n == 0)
                                while (lp != end) {
                                    WR32_LE(-1, lp);
                                    ++lp;
                                }

                            // Check if page is full.
                            if (lp == end) {
                                // Write page of erased list data.
                                if (FtlnMetaWr(ftl, ERASED_LIST))
                                    return -1;

                                // Break if all erased blocks have been recorded.
                                if (n == 0)
                                    break;

                                // Reset pointer to write next entry on new page.
                                lp = (ui32*)(ftl->main_buf + FTLN_META_DATA_BEG);

                                // Assert not at block end. That requires 16B pages.
                                PfAssert(ftl->free_mpn != (ui32)-1);
                            }
                        }

                        // Check if no blocks left to test.
                        if (++b == ftl->num_blks) {
                            // If unwritten data in last page, write it now.
                            if (lp != (ui32*)(ftl->main_buf + FTLN_META_DATA_BEG))
                                if (FtlnMetaWr(ftl, ERASED_LIST))
                                    return -1;

                            // List is finished, break.
                            break;
                        }
                    }

                    // Save elist block number and restore free map page number.
                    ftl->elist_blk = ftl->free_mpn / ftl->pgs_per_blk;
                    ftl->bdata[ftl->elist_blk] = FREE_BLK_FLAG;
                    ++ftl->num_free_blks;
                    ftl->free_mpn = prior_free_mpn;
                }
            }
#endif // INC_ELIST

#if FTLN_DEBUG > 1
            // Display FTL statistics.
            FtlnStats(ftl);
            FtlnBlkStats(ftl);
#endif

            // Return success.
            return 0;
        }

        case FS_FLUSH_PAGE: {
            ui32 vpn, mpn;

            // Use the va_arg mechanism to get virtual page to be flushed.
            va_start(ap, msg);
            vpn = va_arg(ap, ui32);
            va_end(ap);

            // Check argument for validity.
            PfAssert(vpn < ftl->num_vpages);

            // Figure out MPN this page belongs to.
            mpn = vpn / ftl->mappings_per_mpg;

            // Flush MPN from cache. Return -1 if error.
            if (ftlmcFlushPage(ftl->map_cache, mpn))
                return -1;

#if INC_FTL_NDM_MLC
            // For MLC devices, advance free_vpn pointer so next volume page
            // write can't corrupt previously written valid page.
            FtlnMlcSafeFreeVpn(ftl);
#endif

            // Return success.
            return 0;
        }

        case FS_MARK_UNUSED: {
            ui32 ppn, count, past_end, vpn;

            // Use va_arg mechanism to get the starting page and number of
            // pages to be invalidated.
            va_start(ap, msg);
            vpn = va_arg(ap, ui32);
            count = va_arg(ap, ui32);
            va_end(ap);

            // Check arguments for validity.
            if (vpn + count > ftl->num_vpages)
                return -1;

            // Mark page(s) unused in FTL.
            for (past_end = vpn + count; vpn < past_end; ++vpn) {
                // Prepare to potentially write 1 map page. Return -1 if error.
                if (FtlnRecCheck(ftl, -1))
                    return -1;

                // Retrieve physical page number for VPN. Return -1 if error.
                if (FtlnMapGetPpn(ftl, vpn, &ppn) < 0)
                    return -1;

                // If unmapped, skip page.
                if (ppn == (ui32)-1)
                    continue;

#if FS_ASSERT
                // Confirm no physical page number changes below.
                ftl->assert_no_recycle = TRUE;
#endif

                // Assign invalid value to VPN's physical page number and
                // decrement block's used page count.
                if (FtlnMapSetPpn(ftl, vpn, (ui32)-1))
                    return -1;
                PfAssert(ftl->num_free_blks >= FTLN_MIN_FREE_BLKS);
                FtlnDecUsed(ftl, ppn, vpn);

#if FS_ASSERT
                // End check for no physical page number changes.
                ftl->assert_no_recycle = FALSE;
#endif
            }

            // Return success.
            return 0;
        }

        case FS_VSTAT: {
            union vstat* buf;

            // Use the va_arg mechanism to get the vstat buffer.
            va_start(ap, msg);
            buf = (union vstat*)va_arg(ap, void*);
            va_end(ap);

            // Get the garbage level.
            buf->xfs.garbage_level = FtlnGarbLvl(ftl);

            // Get TargetFTL-NDM RAM usage.
            ftl->stats.ram_used = sizeof(struct ftln) + ftl->num_map_pgs * sizeof(ui32) +
                                  ftl->page_size + ftl->eb_size * ftl->pgs_per_blk +
                                  ftlmcRAM(ftl->map_cache) +
                                  ftl->num_blks * (sizeof(ui32) + sizeof(ui8));
#if FTLN_DEBUG > 1
            printf("TargetFTL-NDM RAM usage:\n");
            printf(" - sizeof(Ftln) : %u\n", (int)sizeof(FTLN));
            printf(" - tmp buffers  : %u\n", ftl->page_size + ftl->eb_size * ftl->pgs_per_blk);
            printf(" - map pages    : %u\n", ftl->num_map_pgs * 4);
            printf(" - map cache    : %u\n", ftlmcRAM(ftl->map_cache));
            printf(" - bdata[]      : %u\n", ftl->num_blks * (int)(sizeof(ui32) + sizeof(ui8)));
#endif

            // Record high wear count.
            ftl->stats.wear_count = ftl->high_wc;

            // Set TargetFTL-NDM driver call counts and reset internal ones.
            buf->xfs.drvr_stats.ftl.ndm = ftl->stats;
            memset(&ftl->stats, 0, sizeof(ftl_ndm_stats));

            // Return success.
            return 0;
        }

        case FS_MOUNT:
            // Return error if already mounted. Else set mounted flag.
            if (ftl->flags & FTLN_MOUNTED)
                return FsError2(FTL_MOUNTED, EEXIST);
            ftl->flags |= FTLN_MOUNTED;

#if FTLN_DEBUG > 1
            // Display FTL statistics.
            FtlnStats(ftl);
            FtlnBlkStats(ftl);
#elif FTLN_DEBUG
            printf("FTL: total blocks: %u, free blocks: %u\n", ftl->num_blks, ftl->num_free_blks);
#endif

            // Return success.
            return 0;
    }

    // Return success.
    return 0;
}

#if INC_FTL_NDM_MLC
// FtlnMlcSafeFreeVpn: For MLC devices, ensure free_vpn pointer is
//              on a page whose pair is at a higher offset than the
//              last non-free page
//
//       Input: ftl = pointer to FTL control block
//
void FtlnMlcSafeFreeVpn(FTLN ftl) {
    // Only adjust MLC volumes for which volume free pointer is set.
    if (ftl->free_vpn != (ui32)-1) {
        ui32 pn = ndmPastPrevPair(ftl->ndm, ftl->free_vpn);

#if FTLN_DEBUG
        printf("FtlnMlcSafeFreeVpn: old free = %u, new free = %u\n", ftl->free_vpn, pn);
#endif
        ftl->free_vpn = pn;
    }
}
#endif // INC_FTL_NDM_MLC

// FtlnEraseBlk: Erase a block, increment its wear count, and mark it
//               free and erased
//
//      Inputs: ftl = pointer to FTL control block
//              b = block to erase
//
//     Returns: 0 on success, -1 on error
//
int FtlnEraseBlk(FTLN ftl, ui32 b) {
    ui32 b_wc;

#if INC_ELIST
    // Check if list of erased blocks/wear counts exists.
    if (ftl->elist_blk != (ui32)-1) {
        ui32 eb = ftl->elist_blk;

        // Forget erased list block number.
        ftl->elist_blk = (ui32)-1;

        // If not this block, erase it - because its info is out-of-date.
        if (eb != b)
            if (FtlnEraseBlk(ftl, eb))
                return -1;
    }
#endif

    // Call driver to erase block. Return -1 if error.
    ++ftl->stats.erase_block;
    if (ndmEraseBlock(ftl->start_pn + b * ftl->pgs_per_blk, ftl->ndm))
        return FtlnFatErr(ftl);

    // Increment block wear count and possibly adjust highest.
    b_wc = ftl->high_wc - ftl->blk_wc_lag[b] + 1;
    if (ftl->high_wc < b_wc)
        set_high_wc(ftl, b, b_wc);
    else
        --ftl->blk_wc_lag[b];

    // If not free, increment free blocks count. Mark free and erased.
    if (IS_FREE(ftl->bdata[b]) == FALSE)
        ++ftl->num_free_blks;
    ftl->bdata[b] = FREE_BLK_FLAG | ERASED_BLK_FLAG;

    // Return success.
    return 0;
}

// FtlnLoWcFreeBlk: Find the free block with the lowest wear count
//
//       Input: ftl = pointer to FTL control block
//
//     Returns: block number if successful, else (ui32)-1 if none free
//
ui32 FtlnLoWcFreeBlk(CFTLN ftl) {
    ui32 b, free_b;

    // Search for first free block. Return error if no block is free.
    free_b = first_free_blk(ftl);
    if (free_b == (ui32)-1)
        return free_b;

    // Continue search. Want free block with lowest wear count.
    for (b = free_b + 1; b < ftl->num_blks; ++b)
        if (IS_FREE(ftl->bdata[b]) && (ftl->blk_wc_lag[b] > ftl->blk_wc_lag[free_b]))
            free_b = b;

    // Return block number.
    return free_b;
}

// FtlnHiWcFreeBlk: Find the free block with the highest wear count
//
//       Input: ftl = pointer to FTL control block
//
//     Returns: block number if successful, else (ui32)-1 if none free
//
ui32 FtlnHiWcFreeBlk(CFTLN ftl) {
    ui32 b, free_b;

    // Search for first free block. Return error if no block is free.
    free_b = first_free_blk(ftl);
    if (free_b == (ui32)-1)
        return free_b;

    // Continue search. Want free block with highest wear count.
    for (b = free_b + 1; b < ftl->num_blks; ++b)
        if (IS_FREE(ftl->bdata[b]) && (ftl->blk_wc_lag[b] < ftl->blk_wc_lag[free_b]))
            free_b = b;

    // Return block number.
    return free_b;
}

//  FtlnFormat: Erase all map blocks, mark all blocks free, and reset
//              the FTL (keeping wear offsets)
//
//      Inputs: ftl = pointer to FTL control block
//              meta_block = number of block holding the metapage
//
//     Returns: 0 on success, -1 on error
//
int FtlnFormat(FTLN ftl, ui32 meta_block) {
    ui32 b;

    PfAssert(meta_block < ftl->num_blks);
    // Erase all map blocks, except the one containing the metapage.
    for (b = 0; b < ftl->num_blks; ++b) {
        // Skip non-map blocks.
        if (!IS_MAP_BLK(ftl->bdata[b]))
            continue;

        // Skip block containing the metapage - this will be erased last.
        if (b == meta_block)
            continue;

        // Erase map block. Return -1 if error.
        if (FtlnEraseBlk(ftl, b))
            return -1;
    }

    // Erase the block holding the metapage: format finished!
    if (FtlnEraseBlk(ftl, meta_block))
        return -1;

    // Mark all non-erased blocks as free with zero read wear.
    for (b = 0; b < ftl->num_blks; ++b)
        if (!IS_FREE(ftl->bdata[b]))
            ftl->bdata[b] = FREE_BLK_FLAG;
    ftl->num_free_blks = ftl->num_blks;

    // Re-initialize volume state.
    FtlnStateRst(ftl);
    ftl->high_bc = 1;  // initial block count of unformatted volumes

#if FTLN_DEBUG
    // Display FTL statistics.
    FtlnBlkStats(ftl);
#endif

    // Return success.
    return 0;
}

// FtlnStateRst: Initialize volume state (except wear count offsets)
//
//       Input: ftl = pointer to FTL control block
//
void FtlnStateRst(FTLN ftl) {
    ui32 n;  // TIMER: was 'int'

    ftl->high_bc = 0;
    ftl->high_bc_mblk = ftl->resume_vblk = (ui32)-1;
    ftl->high_bc_mblk_po = 0;
    ftl->copy_end_found = FALSE;
    ftl->max_rc_blk = (ui32)-1;
    ftl->free_vpn = ftl->free_mpn = (ui32)-1;
#if INC_ELIST
    ftl->elist_blk = (ui32)-1;
#endif
    ftl->deferment = 0;
#if FTLN_DEBUG
    ftl->max_wc_lag = 0;
#endif
#if FS_ASSERT
    ftl->assert_no_recycle = FALSE;
#endif
    memset(ftl->spare_buf, 0xFF, ftl->pgs_per_blk * ftl->eb_size);
    for (n = 0; n < ftl->num_map_pgs; ++n) ftl->mpns[n] = (ui32)-1;
    ftlmcInit(ftl->map_cache);
}

// FtlnDecUsed: Decrement block used count for page no longer in-use
//
//      Inputs: ftl = pointer to FTL control block
//              pn = physical page number
//              vpn = virtual page number
//
void FtlnDecUsed(FTLN ftl, ui32 pn, ui32 vpn) {
    ui32 b = pn / ftl->pgs_per_blk;

    // Decrement block used count.
    PfAssert(NUM_USED(ftl->bdata[b]));
    PfAssert(!IS_FREE(ftl->bdata[b]));
    DEC_USED(ftl->bdata[b]);

#if FTLN_DEBUG
    // Read page spare area and assert VPNs match.
    ++ftl->stats.read_spare;
    PfAssert(ndmReadSpare(ftl->start_pn + pn, ftl->spare_buf, ftl->ndm) >= 0);
    PfAssert(GET_SA_VPN(ftl->spare_buf) == vpn);
#endif
} //lint !e818

//  FtlnFatErr: Process FTL-NDM fatal error
//
//       Input: ftl = pointer to FTL control block
//
//     Returns: -1
//
int FtlnFatErr(FTLN ftl) {
    ftl->flags |= FTLN_FATAL_ERR;
    return FsError2(NDM_EIO, EIO);
}

#if FTLN_DEBUG
// flush_bstat: Flush buffered statistics counts
//
//      Inputs: ftl = pointer to FTL control block
//              b = block number of current block
//              type = "FREE", "MAP", or "VOLUME"
//  In/Outputs: *blk0 = first consecutive block number or -1
//              *blke = end consecutive block number
//
static void flush_bstat(CFTLN ftl, int* blk0, int* blke, int b, const char* type) {
    if (*blk0 == -1)
        *blk0 = *blke = b;
    else if (*blke + 1 == b)
        *blke = b;
    else {
        printf("B = %4u", *blk0);
        if (*blk0 == *blke) {
            printf(" - used = %2u, wc lag = %3d, rc = %8u", NUM_USED(ftl->bdata[*blk0]),
                   ftl->blk_wc_lag[*blk0], GET_RC(ftl->bdata[*blk0]));
            printf(" - %s BLOCK\n", type);
        } else {
            printf("-%-4u", *blke);
            printf("%*s", 37, " ");
            printf("- %s BLOCKS\n", type);
        }
        *blk0 = *blke = b;
    }
}

// FtlnBlkStats: Debug function to display blocks statistics
//
//       Input: ftl = pointer to FTL control block
//
void FtlnBlkStats(CFTLN ftl) {
    int free0 = -1, freee, vol0 = -1, vole;
    ui32 b;

    printf(
        "\nBLOCK STATS: %u blocks, %u pages per block, curr free "
        "blocks = %u\n",
        ftl->num_blks, ftl->pgs_per_blk, ftl->num_free_blks);

    // Loop over FTL blocks.
    for (b = 0; b < ftl->num_blks; ++b) {
        // Check if block is free.
        if (IS_FREE(ftl->bdata[b])) {
            flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
            flush_bstat(ftl, &free0, &freee, b, "FREE");
        }

        // Else check if map block.
        else if (IS_MAP_BLK(ftl->bdata[b])) {
            flush_bstat(ftl, &free0, &freee, -1, "FREE");
            flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
            printf("B = %4u - used = %2u, wc lag = %3d, rc = %8u - ", b, NUM_USED(ftl->bdata[b]),
                   ftl->blk_wc_lag[b], GET_RC(ftl->bdata[b]));
            printf("MAP BLOCK\n");
        }

        // Else is volume block.
        else {
            flush_bstat(ftl, &free0, &freee, -1, "FREE");
#if FTLN_DEBUG <= 1
            flush_bstat(ftl, &vol0, &vole, b, "VOLUME");
#else
            printf("B = %4u - used = %2u, wc lag = %3d, rc = %8u - ", b, NUM_USED(ftl->bdata[b]),
                   ftl->blk_wc_lag[b], GET_RC(ftl->bdata[b]));
            printf("VOLUME BLOCK\n");
#endif
        }
    }
    flush_bstat(ftl, &free0, &freee, -1, "FREE");
    flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
}
#endif // FTLN_DEBUG

#if FTLN_DEBUG > 1
//   FtlnStats: Display FTL statistics
//
//       Input: ftl = pointer to FTL control block
//
void FtlnStats(FTLN ftl) {
    ui32 b, n;

    printf("\nFTL STATS:\n");
    printf("  - # vol pages    = %d\n", ftl->num_vpages);
    printf("  - # map pages    = %d\n", ftl->num_map_pgs);
    printf("  - # free blocks  = %d\n", ftl->num_free_blks);
    for (n = b = 0; b < ftl->num_blks; ++b)
        if (IS_ERASED(ftl->bdata[b]))
            ++n;
    printf("  - # erased blks  = %d\n", n);
    printf("  - flags =");
    if (ftl->flags & FTLN_FATAL_ERR)
        printf(" FTLN_FATAL_ERR");
    if (ftl->flags & FTLN_MOUNTED)
        printf(" FTLN_MOUNTED");
    putchar('\n');
}
#endif // FTLN_DEBUG

#if DEBUG_ELIST
// FtlnCheckBlank: Ensure the specified block is blank
//
//      Inputs: ftl = pointer to FTL control block
//              b = block number of block to check
//
void FtlnCheckBlank(FTLN ftl, ui32 b) {
    ui32 pn = b * ftl->pgs_per_blk;
    ui32 end = pn + ftl->pgs_per_blk;
    int rc;

    do {
        rc = ftl->page_check(pn, ftl->main_buf, ftl->spare_buf, ftl->ndm);
        PfAssert(rc == NDM_PAGE_ERASED);
    } while (++pn < end);
}
#endif // DEBUG_ELIST