sys/ufs/chfs/ebh.h

   1 /*      $NetBSD: ebh.h,v 1.3 2012/10/19 12:44:39 ttoth Exp $    */
   2
   3 /*-
   4  * Copyright (c) 2010 Department of Software Engineering,
   5  *                    University of Szeged, Hungary
   6  * Copyright (c) 2010 David Tengeri <dtengeri@inf.u-szeged.hu>
   7  * Copyright (c) 2010 Adam Hoka <ahoka@NetBSD.org>
   8  * All rights reserved.
   9  *
  10  * This code is derived from software contributed to The NetBSD Foundation
  11  * by the Department of Software Engineering, University of Szeged, Hungary
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #ifndef EBH_H_
  36 #define EBH_H_
  37
  38 #ifdef _KERNEL
  39 #include <sys/param.h>
  40 #include <sys/kernel.h>
  41 #include <sys/cdefs.h>
  42 #include <sys/stdint.h>
  43 #include <sys/types.h>
  44 #include <sys/tree.h>
  45 #include <sys/queue.h>
  46 #include <sys/kmem.h>
  47 #include <sys/endian.h>
  48 #include <sys/rwlock.h>
  49 #include <sys/condvar.h>
  50 #include <sys/mutex.h>
  51 #include <sys/kthread.h>
  52
  53 #include <dev/flash/flash.h>
  54 #include "debug.h"
  55 #include "ebh_misc.h"
  56 #endif /* _KERNEL */
  57
  58 #include "ebh_media.h"
  59
  60 /**
  61  * struct  chfs_eb_hdr - in-memory representation of eraseblock headers
  62  * @ec_hdr: erase counter header ob eraseblock
  63  * @u.nor_hdr: eraseblock header on NOR flash
  64  * @u.nand_hdr: eraseblock header on NAND flash
  65  */
  66 struct  chfs_eb_hdr {
  67         struct chfs_eb_ec_hdr ec_hdr;
  68         union {
  69                 struct chfs_nor_eb_hdr  nor_hdr;
  70                 struct chfs_nand_eb_hdr nand_hdr;
  71         } u;
  72 };
  73
  74 #ifdef _KERNEL
  75 /* Maximum retries when getting new PEB before exit with failure */
  76 #define CHFS_MAX_GET_PEB_RETRIES 2
  77
  78 /**
  79  * LEB status
  80  *
  81  */
  82 enum {
  83         EBH_LEB_UNMAPPED = -1,
  84         EBH_LEB_MAPPED,
  85         EBH_LEB_DIRTY,
  86         EBH_LEB_INVALID,
  87         EBH_LEB_ERASE,
  88         EBH_LEB_ERASED,
  89         EBH_LEB_FREE,
  90 };
  91
  92 /**
  93  * EB header status
  94  */
  95 enum {
  96         EBHDR_LEB_OK = 0,
  97         EBHDR_LEB_DIRTY,
  98         EBHDR_LEB_INVALIDATED,
  99         EBHDR_LEB_BADMAGIC,
 100         EBHDR_LEB_BADCRC,
 101         EBHDR_LEB_FREE,
 102         EBHDR_LEB_NO_HDR,
 103 };
 104
 105 struct chfs_ebh;
 106
 107 /**
 108  * struct chfs_ltree_entry - an netry in the lock tree
 109  * @rb: RB-node of the tree
 110  * @lnr: logical eraseblock number
 111  * @users: counts the tasks that are using or want to use the eraseblock
 112  * @mutex: read/write mutex to lock the eraseblock
 113  */
 114 struct chfs_ltree_entry {
 115         RB_ENTRY(chfs_ltree_entry) rb;
 116         int lnr;
 117         int users;
 118         krwlock_t mutex;
 119 };
 120
 121 /* Generate structure for Lock tree's red-black tree */
 122 RB_HEAD(ltree_rbtree, chfs_ltree_entry);
 123
 124
 125 /**
 126  * struct chfs_scan_leb - scanning infomration about a physical eraseblock
 127  * @erase_cnt: erase counter
 128  * @pebnr: physical eraseblock number
 129  * @info: the status of the PEB's eraseblock header when NOR serial when NAND
 130  * @u.list: link in one of the eraseblock list
 131  * @u.rb: link in the used RB-tree of chfs_scan_info
 132  */
 133 struct chfs_scan_leb {
 134         int erase_cnt;
 135         int pebnr;
 136         int lnr;
 137         uint64_t info;
 138         union {
 139                 TAILQ_ENTRY(chfs_scan_leb) queue;
 140                 RB_ENTRY(chfs_scan_leb) rb;
 141         } u;
 142 };
 143
 144 TAILQ_HEAD(scan_leb_queue, chfs_scan_leb);
 145 RB_HEAD(scan_leb_used_rbtree, chfs_scan_leb);
 146
 147
 148 /**
 149  * struct chfs_scan_info - chfs scanning information
 150  * @corrupted: queue of corrupted physical eraseblocks
 151  * @free: queue of free physical eraseblocks
 152  * @erase: queue of the physical eraseblocks signed to erase
 153  * @erased: queue of physical eraseblocks that contain no header
 154  * @used: RB-tree of used PEBs describing by chfs_scan_leb
 155  * @sum_of_ec: summary of erase counters
 156  * @num_of_eb: number of free and used eraseblocks
 157  * @bad_peb_cnt: counter of bad eraseblocks
 158  *
 159  * This structure contains information about the scanning for further
 160  * processing.
 161  */
 162 struct chfs_scan_info {
 163         struct scan_leb_queue corrupted;
 164         struct scan_leb_queue free;
 165         struct scan_leb_queue erase;
 166         struct scan_leb_queue erased;
 167         struct scan_leb_used_rbtree used;
 168         uint64_t sum_of_ec;
 169         int num_of_eb;
 170         int bad_peb_cnt;
 171 };
 172
 173 /**
 174  * struct chfs_peb - PEB information for erasing and wear leveling
 175  * @erase_cnt: erase counter of the physical eraseblock
 176  * @pebnr: physical eraseblock number
 177  * @u.queue: link to the queue of the PEBs waiting for erase
 178  * @u.rb: link to the RB-tree to the free PEBs
 179  */
 180 struct chfs_peb {
 181         int erase_cnt;
 182         int pebnr;
 183         union {
 184                 TAILQ_ENTRY(chfs_peb) queue;
 185                 RB_ENTRY(chfs_peb) rb;
 186         } u;
 187 };
 188
 189 /* Generate queue and rb-tree structures. */
 190 TAILQ_HEAD(peb_queue, chfs_peb);
 191 RB_HEAD(peb_free_rbtree, chfs_peb);
 192 RB_HEAD(peb_in_use_rbtree, chfs_peb);
 193
 194
 195 /*
 196  * struct chfs_ebh_ops - collection of operations which
 197  *                                                               depends on flash type
 198  * *************************************************************************** *
 199  * Direct flash operations:
 200  *
 201  * @read_eb_hdr: read eraseblock header from media
 202  * @write_eb_hdr: write eraseblock header to media
 203  * @check_eb_hdr: validates eraseblock header
 204  * @mark_eb_hdr_dirty_flash: marks eraseblock dirty on flash
 205  * @invalidate_eb_hdr: invalidates eraseblock header
 206  * @mark_eb_hdr_free: marks eraseblock header free (after erase)
 207  * *************************************************************************** *
 208  * Scanning operations:
 209  *
 210  * @process_eb: process an eraseblock information at scan
 211  * *************************************************************************** *
 212  * Misc operations:
 213  *
 214  * @create_eb_hdr: creates an eraseblock header based on flash type
 215  * @calc_data_offs: calculates where the data starts
 216  */
 217 struct chfs_ebh_ops {
 218         int (*read_eb_hdr)(struct chfs_ebh *ebh, int pebnr,
 219             struct chfs_eb_hdr *ebhdr);
 220         int (*write_eb_hdr)(struct chfs_ebh *ebh, int pebnr,
 221             struct chfs_eb_hdr *ebhdr);
 222         int (*check_eb_hdr)(struct chfs_ebh *ebh, void *buf);
 223         int (*mark_eb_hdr_dirty_flash)(struct chfs_ebh *ebh, int pebnr, int lid);
 224         int (*invalidate_eb_hdr)(struct chfs_ebh *ebh, int pebnr);
 225         int (*mark_eb_hdr_free)(struct chfs_ebh *ebh, int pebnr, int ec);
 226
 227         int (*process_eb)(struct chfs_ebh *ebh, struct chfs_scan_info *si,
 228             int pebnr, struct chfs_eb_hdr *ebhdr);
 229
 230         int (*create_eb_hdr)(struct chfs_eb_hdr *ebhdr, int lnr);
 231         int (*calc_data_offs)(struct chfs_ebh *ebh, int pebnr, int offset);
 232 };
 233
 234 /**
 235  * struct erase_thread - background thread for erasing
 236  * @thread: pointer to thread structure
 237  * @wakeup: conditional variable for sleeping if there isn't any job to do
 238  * @running: flag to signal a thread shutdown
 239  */
 240 struct erase_thread {
 241         lwp_t *eth_thread;
 242         kcondvar_t eth_wakeup;
 243         bool eth_running;
 244 };
 245
 246
 247 /**
 248  * struct chfs_ebh - eraseblock handler descriptor
 249  * @mtd: mtd device descriptor
 250  * @eb_size: eraseblock size
 251  * @peb_nr: number of PEBs
 252  * @lmap: LEB to PEB mapping
 253  * @layout_map: the LEBs layout (NOT USED YET)
 254  * @ltree: the lock tree
 255  * @ltree_lock: protects the tree
 256  * @alc_mutex: serializes "atomic LEB change" operation
 257  * @free: RB-tree of the free easeblocks
 258  * @in_use: RB-tree of PEBs are in use
 259  * @to_erase: list of the PEBs waiting for erase
 260  * @fully_erased: list of PEBs that have been erased but don't have header
 261  * @erase_lock: list and tree lock for fully_erased and to_erase lists and
 262  *              for the free RB-tree
 263  * @bg_erase: background thread for eraseing PEBs.
 264  * @ops: collection of operations which depends on flash type
 265  * @max_serial: max serial number of eraseblocks, only used on NAND
 266  */
 267 struct chfs_ebh {
 268         struct peb_free_rbtree free;
 269         struct peb_in_use_rbtree in_use;
 270         struct peb_queue to_erase;
 271         struct peb_queue fully_erased;
 272         struct erase_thread bg_erase;
 273         device_t flash_dev;
 274         const struct flash_interface *flash_if;
 275         struct chfs_ebh_ops *ops;
 276         uint64_t *max_serial;
 277         int *lmap;
 278         //int *layout_map;
 279         struct ltree_rbtree ltree;
 280         //struct mutex alc_mutex;
 281         kmutex_t ltree_lock;
 282         kmutex_t alc_mutex;
 283         kmutex_t erase_lock;
 284         size_t eb_size;
 285         size_t peb_nr;
 286         flash_size_t flash_size;
 287 };
 288
 289 /**
 290  * struct chfs_erase_info_priv - private information for erase
 291  * @ebh: eraseblock handler
 292  * @peb: physical eraseblock information
 293  */
 294 struct chfs_erase_info_priv {
 295         struct chfs_ebh *ebh;
 296         struct chfs_peb *peb;
 297 };
 298
 299 /* ebh.c */
 300
 301 int ebh_open(struct chfs_ebh *ebh, dev_t dev);
 302 int ebh_close(struct chfs_ebh *ebh);
 303 int ebh_read_leb(struct chfs_ebh *ebh, int lnr, char *buf,
 304     uint32_t offset, size_t len, size_t *retlen);
 305 int ebh_write_leb(struct chfs_ebh *ebh, int lnr, char *buf,
 306     uint32_t offset, size_t len, size_t *retlen);
 307 int ebh_erase_leb(struct chfs_ebh *ebh, int lnr);
 308 int ebh_map_leb(struct chfs_ebh *ebh, int lnr);
 309 int ebh_unmap_leb(struct chfs_ebh *ebh, int lnr);
 310 int ebh_is_mapped(struct chfs_ebh *ebh, int lnr);
 311 int ebh_change_leb(struct chfs_ebh *ebh, int lnr, char *buf,
 312     size_t len, size_t *retlen);
 313
 314 #endif /* _KERNEL */
 315
 316 #endif /* EBH_H_ */