Line data    Source code

       1             : /*   SPDX-License-Identifier: BSD-3-Clause
       2             :  *   Copyright (C) 2022 Intel Corporation.
       3             :  *   All rights reserved.
       4             :  */
       5             : 
       6             : #include "ftl_l2p.h"
       7             : #include "ftl_core.h"
       8             : #include "ftl_band.h"
       9             : #include "ftl_utils.h"
      10             : #include "ftl_l2p_flat.h"
      11             : #include "utils/ftl_addr_utils.h"
      12             : 
      13             : static struct ftl_md *
      14           0 : get_l2p_md(struct spdk_ftl_dev *dev)
      15             : {
      16           0 :         return dev->layout.md[FTL_LAYOUT_REGION_TYPE_L2P];
      17             : }
      18             : 
      19             : struct ftl_l2p_flat {
      20             :         void *l2p;
      21             :         bool is_halted;
      22             : };
      23             : 
      24             : void
      25           0 : ftl_l2p_flat_pin(struct spdk_ftl_dev *dev, struct ftl_l2p_pin_ctx *pin_ctx)
      26             : {
      27           0 :         assert(dev->num_lbas >= pin_ctx->lba + pin_ctx->count);
      28             : 
      29           0 :         ftl_l2p_pin_complete(dev, 0, pin_ctx);
      30           0 : }
      31             : 
      32             : void
      33           0 : ftl_l2p_flat_unpin(struct spdk_ftl_dev *dev, uint64_t lba, uint64_t count)
      34             : {
      35           0 :         assert(dev->num_lbas >= lba + count);
      36           0 : }
      37             : 
      38             : void
      39           0 : ftl_l2p_flat_set(struct spdk_ftl_dev *dev, uint64_t lba, ftl_addr addr)
      40             : {
      41           0 :         struct ftl_l2p_flat *l2p_flat = dev->l2p;
      42             : 
      43           0 :         assert(dev->num_lbas > lba);
      44             : 
      45           0 :         ftl_addr_store(dev, l2p_flat->l2p, lba, addr);
      46           0 : }
      47             : 
      48             : ftl_addr
      49           0 : ftl_l2p_flat_get(struct spdk_ftl_dev *dev, uint64_t lba)
      50             : {
      51           0 :         struct ftl_l2p_flat *l2p_flat = dev->l2p;
      52             : 
      53           0 :         assert(dev->num_lbas > lba);
      54             : 
      55           0 :         return ftl_addr_load(dev, l2p_flat->l2p, lba);
      56           0 : }
      57             : 
      58             : static void
      59           0 : md_cb(struct spdk_ftl_dev *dev, struct ftl_md *md, int status)
      60             : {
      61           0 :         ftl_l2p_cb cb = md->owner.private;
      62           0 :         void *cb_ctx = md->owner.cb_ctx;
      63             : 
      64           0 :         cb(dev, status, cb_ctx);
      65           0 : }
      66             : 
      67             : void
      68           0 : ftl_l2p_flat_clear(struct spdk_ftl_dev *dev, ftl_l2p_cb cb, void *cb_ctx)
      69             : {
      70           0 :         struct ftl_l2p_flat *l2p_flat = dev->l2p;
      71           0 :         struct ftl_md *md;
      72             : 
      73           0 :         memset(l2p_flat->l2p, (int)FTL_ADDR_INVALID,
      74           0 :                ftl_md_get_buffer_size(get_l2p_md(dev)));
      75             : 
      76           0 :         md = get_l2p_md(dev);
      77           0 :         md->cb = md_cb;
      78           0 :         md->owner.cb_ctx = cb_ctx;
      79           0 :         md->owner.private = cb;
      80           0 :         ftl_md_persist(md);
      81           0 : }
      82             : 
      83             : void
      84           0 : ftl_l2p_flat_restore(struct spdk_ftl_dev *dev, ftl_l2p_cb cb, void *cb_ctx)
      85             : {
      86           0 :         struct ftl_md *md;
      87             : 
      88           0 :         md = get_l2p_md(dev);
      89           0 :         md->cb = md_cb;
      90           0 :         md->owner.cb_ctx = cb_ctx;
      91           0 :         md->owner.private = cb;
      92           0 :         ftl_md_restore(md);
      93           0 : }
      94             : 
      95             : void
      96           0 : ftl_l2p_flat_persist(struct spdk_ftl_dev *dev, ftl_l2p_cb cb, void *cb_ctx)
      97             : {
      98           0 :         struct ftl_md *md;
      99             : 
     100           0 :         md = get_l2p_md(dev);
     101           0 :         md->cb = md_cb;
     102           0 :         md->owner.cb_ctx = cb_ctx;
     103           0 :         md->owner.private = cb;
     104           0 :         ftl_md_persist(md);
     105           0 : }
     106             : 
     107             : static int
     108           0 : ftl_l2p_flat_init_dram(struct spdk_ftl_dev *dev, struct ftl_l2p_flat *l2p_flat,
     109             :                        size_t l2p_size)
     110             : {
     111           0 :         struct ftl_md *md = get_l2p_md(dev);
     112             : 
     113           0 :         assert(ftl_md_get_buffer_size(md) >= l2p_size);
     114             : 
     115           0 :         l2p_flat->l2p = ftl_md_get_buffer(md);
     116           0 :         if (!l2p_flat->l2p) {
     117           0 :                 FTL_ERRLOG(dev, "Failed to allocate l2p table\n");
     118           0 :                 return -1;
     119             :         }
     120             : 
     121           0 :         return 0;
     122           0 : }
     123             : 
     124             : int
     125           0 : ftl_l2p_flat_init(struct spdk_ftl_dev *dev)
     126             : {
     127           0 :         size_t l2p_size = dev->num_lbas * dev->layout.l2p.addr_size;
     128           0 :         struct ftl_l2p_flat *l2p_flat;
     129           0 :         int ret;
     130             : 
     131           0 :         if (dev->num_lbas == 0) {
     132           0 :                 FTL_ERRLOG(dev, "Invalid l2p table size\n");
     133           0 :                 return -1;
     134             :         }
     135             : 
     136           0 :         if (dev->l2p) {
     137           0 :                 FTL_ERRLOG(dev, "L2p table already allocated\n");
     138           0 :                 return -1;
     139             :         }
     140             : 
     141           0 :         l2p_flat = calloc(1, sizeof(*l2p_flat));
     142           0 :         if (!l2p_flat) {
     143           0 :                 FTL_ERRLOG(dev, "Failed to allocate l2p_flat\n");
     144           0 :                 return -1;
     145             :         }
     146             : 
     147           0 :         ret = ftl_l2p_flat_init_dram(dev, l2p_flat, l2p_size);
     148             : 
     149           0 :         if (ret) {
     150           0 :                 free(l2p_flat);
     151           0 :                 return ret;
     152             :         }
     153             : 
     154           0 :         dev->l2p = l2p_flat;
     155           0 :         return 0;
     156           0 : }
     157             : 
     158             : void
     159           0 : ftl_l2p_flat_deinit(struct spdk_ftl_dev *dev)
     160             : {
     161           0 :         struct ftl_l2p_flat *l2p_flat = dev->l2p;
     162             : 
     163           0 :         if (!l2p_flat) {
     164           0 :                 return;
     165             :         }
     166             : 
     167           0 :         free(l2p_flat);
     168             : 
     169           0 :         dev->l2p = NULL;
     170           0 : }
     171             : 
     172             : void
     173           0 : ftl_l2p_flat_trim(struct spdk_ftl_dev *dev, ftl_l2p_cb cb, void *cb_ctx)
     174             : {
     175           0 :         cb(dev, 0, cb_ctx);
     176           0 : }
     177             : 
     178             : void
     179           0 : ftl_l2p_flat_process(struct spdk_ftl_dev *dev)
     180             : {
     181           0 : }
     182             : 
     183             : bool
     184           0 : ftl_l2p_flat_is_halted(struct spdk_ftl_dev *dev)
     185             : {
     186           0 :         return true;
     187             : }
     188             : 
     189             : void
     190           0 : ftl_l2p_flat_halt(struct spdk_ftl_dev *dev)
     191             : {
     192           0 : }
     193             : 
     194             : void
     195           0 : ftl_l2p_flat_resume(struct spdk_ftl_dev *dev)
     196             : {
     197           0 : }