sys/ufs/chfs/ebh.c

   1 /*      $NetBSD: ebh.c,v 1.6 2015/02/07 04:21:11 christos Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2010 Department of Software Engineering,
   5  *                    University of Szeged, Hungary
   6  * Copyright (C) 2009 Ferenc Havasi <havasi@inf.u-szeged.hu>
   7  * Copyright (C) 2009 Zoltan Sogor <weth@inf.u-szeged.hu>
   8  * Copyright (C) 2009 David Tengeri <dtengeri@inf.u-szeged.hu>
   9  * Copyright (C) 2009 Tamas Toth <ttoth@inf.u-szeged.hu>
  10  * Copyright (C) 2010 Adam Hoka <ahoka@NetBSD.org>
  11  * All rights reserved.
  12  *
  13  * This code is derived from software contributed to The NetBSD Foundation
  14  * by the Department of Software Engineering, University of Szeged, Hungary
  15  *
  16  * Redistribution and use in source and binary forms, with or without
  17  * modification, are permitted provided that the following conditions
  18  * are met:
  19  * 1. Redistributions of source code must retain the above copyright
  20  *    notice, this list of conditions and the following disclaimer.
  21  * 2. Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in the
  23  *    documentation and/or other materials provided with the distribution.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  26  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  27  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  28  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  32  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  33  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  */
  37
  38 #include "ebh.h"
  39
  40 /*****************************************************************************/
  41 /* Flash specific operations                                                 */
  42 /*****************************************************************************/
  43 int nor_create_eb_hdr(struct chfs_eb_hdr *ebhdr, int lnr);
  44 int nand_create_eb_hdr(struct chfs_eb_hdr *ebhdr, int lnr);
  45 int nor_calc_data_offs(struct chfs_ebh *ebh, int pebnr, int offset);
  46 int nand_calc_data_offs(struct chfs_ebh *ebh, int pebnr, int offset);
  47 int nor_read_eb_hdr(struct chfs_ebh *ebh, int pebnr, struct chfs_eb_hdr *ebhdr);
  48 int nand_read_eb_hdr(struct chfs_ebh *ebh, int pebnr, struct chfs_eb_hdr *ebhdr);
  49 int nor_write_eb_hdr(struct chfs_ebh *ebh, int pebnr, struct chfs_eb_hdr *ebhdr);
  50 int nand_write_eb_hdr(struct chfs_ebh *ebh, int pebnr,struct chfs_eb_hdr *ebhdr);
  51 int nor_check_eb_hdr(struct chfs_ebh *ebh, void *buf);
  52 int nand_check_eb_hdr(struct chfs_ebh *ebh, void *buf);
  53 int nor_mark_eb_hdr_dirty_flash(struct chfs_ebh *ebh, int pebnr, int lid);
  54 int nor_invalidate_eb_hdr(struct chfs_ebh *ebh, int pebnr);
  55 int mark_eb_hdr_free(struct chfs_ebh *ebh, int pebnr, int ec);
  56
  57 int ltree_entry_cmp(struct chfs_ltree_entry *le1, struct chfs_ltree_entry *le2);
  58 int peb_in_use_cmp(struct chfs_peb *peb1, struct chfs_peb *peb2);
  59 int peb_free_cmp(struct chfs_peb *peb1, struct chfs_peb *peb2);
  60 int add_peb_to_erase_queue(struct chfs_ebh *ebh, int pebnr, int ec,struct peb_queue *queue);
  61 struct chfs_peb * find_peb_in_use(struct chfs_ebh *ebh, int pebnr);
  62 int add_peb_to_free(struct chfs_ebh *ebh, int pebnr, int ec);
  63 int add_peb_to_in_use(struct chfs_ebh *ebh, int pebnr, int ec);
  64 void erase_callback(struct flash_erase_instruction *ei);
  65 int free_peb(struct chfs_ebh *ebh);
  66 int release_peb(struct chfs_ebh *ebh, int pebnr);
  67 void erase_thread(void *data);
  68 static void erase_thread_start(struct chfs_ebh *ebh);
  69 static void erase_thread_stop(struct chfs_ebh *ebh);
  70 int scan_leb_used_cmp(struct chfs_scan_leb *sleb1, struct chfs_scan_leb *sleb2);
  71 int nor_scan_add_to_used(struct chfs_ebh *ebh, struct chfs_scan_info *si,struct chfs_eb_hdr *ebhdr, int pebnr, int leb_status);
  72 int nor_process_eb(struct chfs_ebh *ebh, struct chfs_scan_info *si,
  73     int pebnr, struct chfs_eb_hdr *ebhdr);
  74 int nand_scan_add_to_used(struct chfs_ebh *ebh, struct chfs_scan_info *si,struct chfs_eb_hdr *ebhdr, int pebnr);
  75 int nand_process_eb(struct chfs_ebh *ebh, struct chfs_scan_info *si,
  76     int pebnr, struct chfs_eb_hdr *ebhdr);
  77 struct chfs_scan_info *chfs_scan(struct chfs_ebh *ebh);
  78 void scan_info_destroy(struct chfs_scan_info *si);
  79 int scan_media(struct chfs_ebh *ebh);
  80 int get_peb(struct chfs_ebh *ebh);
  81 /**
  82  * nor_create_eb_hdr - creates an eraseblock header for NOR flash
  83  * @ebhdr: ebhdr to set
  84  * @lnr: LEB number
  85  */
  86 int
  87 nor_create_eb_hdr(struct chfs_eb_hdr *ebhdr, int lnr)
  88 {
  89         ebhdr->u.nor_hdr.lid = htole32(lnr);
  90         return 0;
  91 }
  92
  93 /**
  94  * nand_create_eb_hdr - creates an eraseblock header for NAND flash
  95  * @ebhdr: ebhdr to set
  96  * @lnr: LEB number
  97  */
  98 int
  99 nand_create_eb_hdr(struct chfs_eb_hdr *ebhdr, int lnr)
 100 {
 101         ebhdr->u.nand_hdr.lid = htole32(lnr);
 102         return 0;
 103 }
 104
 105 /**
 106  * nor_calc_data_offs - calculates data offset on NOR flash
 107  * @ebh: chfs eraseblock handler
 108  * @pebnr: eraseblock number
 109  * @offset: offset within the eraseblock
 110  */
 111 int
 112 nor_calc_data_offs(struct chfs_ebh *ebh, int pebnr, int offset)
 113 {
 114         return pebnr * ebh->flash_if->erasesize + offset +
 115             CHFS_EB_EC_HDR_SIZE + CHFS_EB_HDR_NOR_SIZE;
 116 }
 117
 118 /**
 119  * nand_calc_data_offs - calculates data offset on NAND flash
 120  * @ebh: chfs eraseblock handler
 121  * @pebnr: eraseblock number
 122  * @offset: offset within the eraseblock
 123  */
 124 int
 125 nand_calc_data_offs(struct chfs_ebh *ebh, int pebnr, int offset)
 126 {
 127         return pebnr * ebh->flash_if->erasesize + offset +
 128             2 * ebh->flash_if->page_size;
 129 }
 130
 131 /**
 132  * nor_read_eb_hdr - read ereaseblock header from NOR flash
 133  *
 134  * @ebh: chfs eraseblock handler
 135  * @pebnr: eraseblock number
 136  * @ebhdr: whereto store the data
 137  *
 138  * Reads the eraseblock header from media.
 139  * Returns zero in case of success, error code in case of fail.
 140  */
 141 int
 142 nor_read_eb_hdr(struct chfs_ebh *ebh,
 143     int pebnr, struct chfs_eb_hdr *ebhdr)
 144 {
 145         int ret;
 146         size_t retlen;
 147         off_t ofs = pebnr * ebh->flash_if->erasesize;
 148
 149         KASSERT(pebnr >= 0 && pebnr < ebh->peb_nr);
 150
 151         ret = flash_read(ebh->flash_dev,
 152             ofs, CHFS_EB_EC_HDR_SIZE,
 153             &retlen, (unsigned char *) &ebhdr->ec_hdr);
 154
 155         if (ret || retlen != CHFS_EB_EC_HDR_SIZE)
 156                 return ret;
 157
 158         ofs += CHFS_EB_EC_HDR_SIZE;
 159         ret = flash_read(ebh->flash_dev,
 160             ofs, CHFS_EB_HDR_NOR_SIZE,
 161             &retlen, (unsigned char *) &ebhdr->u.nor_hdr);
 162
 163         if (ret || retlen != CHFS_EB_HDR_NOR_SIZE)
 164                 return ret;
 165
 166         return 0;
 167 }
 168
 169 /**
 170  * nand_read_eb_hdr - read ereaseblock header from NAND flash
 171  *
 172  * @ebh: chfs eraseblock handler
 173  * @pebnr: eraseblock number
 174  * @ebhdr: whereto store the data
 175  *
 176  * Reads the eraseblock header from media. It is on the first two page.
 177  * Returns zero in case of success, error code in case of fail.
 178  */
 179 int
 180 nand_read_eb_hdr(struct chfs_ebh *ebh, int pebnr,
 181     struct chfs_eb_hdr *ebhdr)
 182 {
 183         int ret;
 184         size_t retlen;
 185         off_t ofs;
 186
 187         KASSERT(pebnr >= 0 && pebnr < ebh->peb_nr);
 188
 189         /* Read erase counter header from the first page. */
 190         ofs = pebnr * ebh->flash_if->erasesize;
 191         ret = flash_read(ebh->flash_dev,
 192             ofs, CHFS_EB_EC_HDR_SIZE, &retlen,
 193             (unsigned char *) &ebhdr->ec_hdr);
 194         if (ret || retlen != CHFS_EB_EC_HDR_SIZE)
 195                 return ret;
 196
 197         /* Read NAND eraseblock header from the second page */
 198         ofs += ebh->flash_if->page_size;
 199         ret = flash_read(ebh->flash_dev,
 200             ofs, CHFS_EB_HDR_NAND_SIZE, &retlen,
 201             (unsigned char *) &ebhdr->u.nand_hdr);
 202         if (ret || retlen != CHFS_EB_HDR_NAND_SIZE)
 203                 return ret;
 204
 205         return 0;
 206 }
 207
 208 /**
 209  * nor_write_eb_hdr - write ereaseblock header to NOR flash
 210  *
 211  * @ebh: chfs eraseblock handler
 212  * @pebnr: eraseblock number whereto write
 213  * @ebh: ebh to write
 214  *
 215  * Writes the eraseblock header to media.
 216  * Returns zero in case of success, error code in case of fail.
 217  */
 218 int
 219 nor_write_eb_hdr(struct chfs_ebh *ebh, int pebnr, struct chfs_eb_hdr *ebhdr)
 220 {
 221         int ret, crc;
 222         size_t retlen;
 223
 224         off_t ofs = pebnr * ebh->flash_if->erasesize + CHFS_EB_EC_HDR_SIZE;
 225
 226         ebhdr->u.nor_hdr.lid = ebhdr->u.nor_hdr.lid
 227             | htole32(CHFS_LID_NOT_DIRTY_BIT);
 228
 229         crc = crc32(0, (uint8_t *)&ebhdr->u.nor_hdr + 4,
 230             CHFS_EB_HDR_NOR_SIZE - 4);
 231         ebhdr->u.nand_hdr.crc = htole32(crc);
 232
 233         KASSERT(pebnr >= 0 && pebnr < ebh->peb_nr);
 234
 235         ret = flash_write(ebh->flash_dev,
 236             ofs, CHFS_EB_HDR_NOR_SIZE, &retlen,
 237             (unsigned char *) &ebhdr->u.nor_hdr);
 238
 239         if (ret || retlen != CHFS_EB_HDR_NOR_SIZE)
 240                 return ret;
 241
 242         return 0;
 243 }
 244
 245 /**
 246  * nand_write_eb_hdr - write ereaseblock header to NAND flash
 247  *
 248  * @ebh: chfs eraseblock handler
 249  * @pebnr: eraseblock number whereto write
 250  * @ebh: ebh to write
 251  *
 252  * Writes the eraseblock header to media.
 253  * Returns zero in case of success, error code in case of fail.
 254  */
 255 int
 256 nand_write_eb_hdr(struct chfs_ebh *ebh, int pebnr,
 257     struct chfs_eb_hdr *ebhdr)
 258 {
 259         int ret, crc;
 260         size_t retlen;
 261         flash_off_t ofs;
 262
 263         KASSERT(pebnr >= 0 && pebnr < ebh->peb_nr);
 264
 265         ofs = pebnr * ebh->flash_if->erasesize +
 266             ebh->flash_if->page_size;
 267
 268         ebhdr->u.nand_hdr.serial = htole64(++(*ebh->max_serial));
 269
 270         crc = crc32(0, (uint8_t *)&ebhdr->u.nand_hdr + 4,
 271             CHFS_EB_HDR_NAND_SIZE - 4);
 272         ebhdr->u.nand_hdr.crc = htole32(crc);
 273
 274         ret = flash_write(ebh->flash_dev, ofs,
 275             CHFS_EB_HDR_NAND_SIZE, &retlen,
 276             (unsigned char *) &ebhdr->u.nand_hdr);
 277
 278         if (ret || retlen != CHFS_EB_HDR_NAND_SIZE)
 279                 return ret;
 280
 281         return 0;
 282 }
 283
 284 /**
 285  * nor_check_eb_hdr - check ereaseblock header read from NOR flash
 286  *
 287  * @ebh: chfs eraseblock handler
 288  * @buf: eraseblock header to check
 289  *
 290  * Returns eraseblock header status.
 291  */
 292 int
 293 nor_check_eb_hdr(struct chfs_ebh *ebh, void *buf)
 294 {
 295         uint32_t magic, crc, hdr_crc;
 296         struct chfs_eb_hdr *ebhdr = buf;
 297         le32 lid_save;
 298
 299         //check is there a header
 300         if (check_pattern((void *) &ebhdr->ec_hdr,
 301                 0xFF, 0, CHFS_EB_EC_HDR_SIZE)) {
 302                 dbg_ebh("no header found\n");
 303                 return EBHDR_LEB_NO_HDR;
 304         }
 305
 306         // check magic
 307         magic = le32toh(ebhdr->ec_hdr.magic);
 308         if (magic != CHFS_MAGIC_BITMASK) {
 309                 dbg_ebh("bad magic bitmask(exp: %x found %x)\n",
 310                     CHFS_MAGIC_BITMASK, magic);
 311                 return EBHDR_LEB_BADMAGIC;
 312         }
 313
 314         // check CRC_EC
 315         hdr_crc = le32toh(ebhdr->ec_hdr.crc_ec);
 316         crc = crc32(0, (uint8_t *) &ebhdr->ec_hdr + 8, 4);
 317         if (hdr_crc != crc) {
 318                 dbg_ebh("bad crc_ec found\n");
 319                 return EBHDR_LEB_BADCRC;
 320         }
 321
 322         /* check if the PEB is free: magic, crc_ec and erase_cnt is good and
 323          * everything else is FFF..
 324          */
 325         if (check_pattern((void *) &ebhdr->u.nor_hdr, 0xFF, 0,
 326                 CHFS_EB_HDR_NOR_SIZE)) {
 327                 dbg_ebh("free peb found\n");
 328                 return EBHDR_LEB_FREE;
 329         }
 330
 331         // check invalidated (CRC == LID == 0)
 332         if (ebhdr->u.nor_hdr.crc == 0 && ebhdr->u.nor_hdr.lid == 0) {
 333                 dbg_ebh("invalidated ebhdr found\n");
 334                 return EBHDR_LEB_INVALIDATED;
 335         }
 336
 337         // check CRC
 338         hdr_crc = le32toh(ebhdr->u.nor_hdr.crc);
 339         lid_save = ebhdr->u.nor_hdr.lid;
 340
 341         // mark lid as not dirty for crc calc
 342         ebhdr->u.nor_hdr.lid = ebhdr->u.nor_hdr.lid | htole32(
 343                 CHFS_LID_NOT_DIRTY_BIT);
 344         crc = crc32(0, (uint8_t *) &ebhdr->u.nor_hdr + 4,
 345             CHFS_EB_HDR_NOR_SIZE - 4);
 346         // restore the original lid value in ebh
 347         ebhdr->u.nor_hdr.lid = lid_save;
 348
 349         if (crc != hdr_crc) {
 350                 dbg_ebh("bad crc found\n");
 351                 return EBHDR_LEB_BADCRC;
 352         }
 353
 354         // check dirty
 355         if (!(le32toh(lid_save) & CHFS_LID_NOT_DIRTY_BIT)) {
 356                 dbg_ebh("dirty ebhdr found\n");
 357                 return EBHDR_LEB_DIRTY;
 358         }
 359
 360         return EBHDR_LEB_OK;
 361 }
 362
 363 /**
 364  * nand_check_eb_hdr - check ereaseblock header read from NAND flash
 365  *
 366  * @ebh: chfs eraseblock handler
 367  * @buf: eraseblock header to check
 368  *
 369  * Returns eraseblock header status.
 370  */
 371 int
 372 nand_check_eb_hdr(struct chfs_ebh *ebh, void *buf)
 373 {
 374         uint32_t magic, crc, hdr_crc;
 375         struct chfs_eb_hdr *ebhdr = buf;
 376
 377         //check is there a header
 378         if (check_pattern((void *) &ebhdr->ec_hdr,
 379                 0xFF, 0, CHFS_EB_EC_HDR_SIZE)) {
 380                 dbg_ebh("no header found\n");
 381                 return EBHDR_LEB_NO_HDR;
 382         }
 383
 384         // check magic
 385         magic = le32toh(ebhdr->ec_hdr.magic);
 386         if (magic != CHFS_MAGIC_BITMASK) {
 387                 dbg_ebh("bad magic bitmask(exp: %x found %x)\n",
 388                     CHFS_MAGIC_BITMASK, magic);
 389                 return EBHDR_LEB_BADMAGIC;
 390         }
 391
 392         // check CRC_EC
 393         hdr_crc = le32toh(ebhdr->ec_hdr.crc_ec);
 394         crc = crc32(0, (uint8_t *) &ebhdr->ec_hdr + 8, 4);
 395         if (hdr_crc != crc) {
 396                 dbg_ebh("bad crc_ec found\n");
 397                 return EBHDR_LEB_BADCRC;
 398         }
 399
 400         /* check if the PEB is free: magic, crc_ec and erase_cnt is good and
 401          * everything else is FFF..
 402          */
 403         if (check_pattern((void *) &ebhdr->u.nand_hdr, 0xFF, 0,
 404                 CHFS_EB_HDR_NAND_SIZE)) {
 405                 dbg_ebh("free peb found\n");
 406                 return EBHDR_LEB_FREE;
 407         }
 408
 409         // check CRC
 410         hdr_crc = le32toh(ebhdr->u.nand_hdr.crc);
 411
 412         crc = crc32(0, (uint8_t *) &ebhdr->u.nand_hdr + 4,
 413             CHFS_EB_HDR_NAND_SIZE - 4);
 414
 415         if (crc != hdr_crc) {
 416                 dbg_ebh("bad crc found\n");
 417                 return EBHDR_LEB_BADCRC;
 418         }
 419
 420         return EBHDR_LEB_OK;
 421 }
 422
 423 /**
 424  * nor_mark_eb_hdr_dirty_flash- mark ereaseblock header dirty on NOR flash
 425  *
 426  * @ebh: chfs eraseblock handler
 427  * @pebnr: eraseblock number
 428  * @lid: leb id (its bit number 31 will be set to 0)
 429  *
 430  * It pulls the CHFS_LID_NOT_DIRTY_BIT to zero on flash.
 431  *
 432  * Returns zero in case of success, error code in case of fail.
 433  */
 434 int
 435 nor_mark_eb_hdr_dirty_flash(struct chfs_ebh *ebh, int pebnr, int lid)
 436 {
 437         int ret;
 438         size_t retlen;
 439         off_t ofs;
 440
 441         /* mark leb id dirty */
 442         lid = htole32(lid & CHFS_LID_DIRTY_BIT_MASK);
 443
 444         /* calculate position */
 445         ofs = pebnr * ebh->flash_if->erasesize + CHFS_EB_EC_HDR_SIZE
 446             + CHFS_GET_MEMBER_POS(struct chfs_nor_eb_hdr , lid);
 447
 448         ret = flash_write(ebh->flash_dev, ofs, sizeof(lid), &retlen,
 449             (unsigned char *) &lid);
 450         if (ret || retlen != sizeof(lid)) {
 451                 chfs_err("can't mark peb dirty");
 452                 return ret;
 453         }
 454
 455         return 0;
 456 }
 457
 458 /**
 459  * nor_invalidate_eb_hdr - invalidate ereaseblock header on NOR flash
 460  *
 461  * @ebh: chfs eraseblock handler
 462  * @pebnr: eraseblock number
 463  *
 464  * Sets crc and lip field to zero.
 465  * Returns zero in case of success, error code in case of fail.
 466  */
 467 int
 468 nor_invalidate_eb_hdr(struct chfs_ebh *ebh, int pebnr)
 469 {
 470         int ret;
 471         size_t retlen;
 472         off_t ofs;
 473         char zero_buf[CHFS_INVALIDATE_SIZE];
 474
 475         /* fill with zero */
 476         memset(zero_buf, 0x0, CHFS_INVALIDATE_SIZE);
 477
 478         /* calculate position (!!! lid is directly behind crc !!!) */
 479         ofs = pebnr * ebh->flash_if->erasesize + CHFS_EB_EC_HDR_SIZE
 480             + CHFS_GET_MEMBER_POS(struct chfs_nor_eb_hdr, crc);
 481
 482         ret = flash_write(ebh->flash_dev,
 483             ofs, CHFS_INVALIDATE_SIZE, &retlen,
 484             (unsigned char *) &zero_buf);
 485         if (ret || retlen != CHFS_INVALIDATE_SIZE) {
 486                 chfs_err("can't invalidate peb");
 487                 return ret;
 488         }
 489
 490         return 0;
 491 }
 492
 493 /**
 494  * mark_eb_hdr_free - free ereaseblock header on NOR or NAND flash
 495  *
 496  * @ebh: chfs eraseblock handler
 497  * @pebnr: eraseblock number
 498  * @ec: erase counter of PEB
 499  *
 500  * Write out the magic and erase counter to the physical eraseblock.
 501  * Returns zero in case of success, error code in case of fail.
 502  */
 503 int
 504 mark_eb_hdr_free(struct chfs_ebh *ebh, int pebnr, int ec)
 505 {
 506         int ret, crc;
 507         size_t retlen;
 508         off_t ofs;
 509         struct chfs_eb_hdr *ebhdr;
 510         ebhdr = kmem_alloc(sizeof(struct chfs_eb_hdr), KM_SLEEP);
 511
 512         ebhdr->ec_hdr.magic = htole32(CHFS_MAGIC_BITMASK);
 513         ebhdr->ec_hdr.erase_cnt = htole32(ec);
 514         crc = crc32(0, (uint8_t *) &ebhdr->ec_hdr + 8, 4);
 515         ebhdr->ec_hdr.crc_ec = htole32(crc);
 516
 517         ofs = pebnr * ebh->flash_if->erasesize;
 518
 519         KASSERT(sizeof(ebhdr->ec_hdr) == CHFS_EB_EC_HDR_SIZE);
 520
 521         ret = flash_write(ebh->flash_dev,
 522             ofs, CHFS_EB_EC_HDR_SIZE, &retlen,
 523             (unsigned char *) &ebhdr->ec_hdr);
 524
 525         if (ret || retlen != CHFS_EB_EC_HDR_SIZE) {
 526                 chfs_err("can't mark peb as free: %d\n", pebnr);
 527                 kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
 528                 return ret;
 529         }
 530
 531         kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
 532         return 0;
 533 }
 534
 535 /*****************************************************************************/
 536 /* End of Flash specific operations                                          */
 537 /*****************************************************************************/
 538
 539 /*****************************************************************************/
 540 /* Lock Tree                                                                 */
 541 /*****************************************************************************/
 542
 543 int
 544 ltree_entry_cmp(struct chfs_ltree_entry *le1,
 545     struct chfs_ltree_entry *le2)
 546 {
 547         return (le1->lnr - le2->lnr);
 548 }
 549
 550 /* Generate functions for Lock tree's red-black tree */
 551 RB_PROTOTYPE( ltree_rbtree, chfs_ltree_entry, rb, ltree_entry_cmp);
 552 RB_GENERATE( ltree_rbtree, chfs_ltree_entry, rb, ltree_entry_cmp);
 553
 554
 555 /**
 556  * ltree_lookup - looks up a logical eraseblock in the lock tree
 557  * @ebh: chfs eraseblock handler
 558  * @lid: identifier of the logical eraseblock
 559  *
 560  * This function returns a pointer to the wanted &struct chfs_ltree_entry
 561  * if the logical eraseblock is in the lock tree, so it is locked, NULL
 562  * otherwise.
 563  * @ebh->ltree_lock has to be locked!
 564  */
 565 static struct chfs_ltree_entry *
 566 ltree_lookup(struct chfs_ebh *ebh, int lnr)
 567 {
 568         struct chfs_ltree_entry le, *result;
 569         le.lnr = lnr;
 570         result = RB_FIND(ltree_rbtree, &ebh->ltree, &le);
 571         return result;
 572 }
 573
 574 /**
 575  * ltree_add_entry - add an entry to the lock tree
 576  * @ebh: chfs eraseblock handler
 577  * @lnr: identifier of the logical eraseblock
 578  *
 579  * This function adds a new logical eraseblock entry identified with @lnr to the
 580  * lock tree. If the entry is already in the tree, it increases the user
 581  * counter.
 582  * Returns NULL if can not allocate memory for lock tree entry, or a pointer
 583  * to the inserted entry otherwise.
 584  */
 585 static struct chfs_ltree_entry *
 586 ltree_add_entry(struct chfs_ebh *ebh, int lnr)
 587 {
 588         struct chfs_ltree_entry *le, *result;
 589
 590         le = kmem_alloc(sizeof(struct chfs_ltree_entry), KM_SLEEP);
 591
 592         le->lnr = lnr;
 593         le->users = 1;
 594         rw_init(&le->mutex);
 595
 596         //dbg_ebh("enter ltree lock\n");
 597         mutex_enter(&ebh->ltree_lock);
 598         //dbg_ebh("insert\n");
 599         result = RB_INSERT(ltree_rbtree, &ebh->ltree, le);
 600         //dbg_ebh("inserted\n");
 601         if (result) {
 602                 //The entry is already in the tree
 603                 result->users++;
 604                 kmem_free(le, sizeof(struct chfs_ltree_entry));
 605         }
 606         else {
 607                 result = le;
 608         }
 609         mutex_exit(&ebh->ltree_lock);
 610
 611         return result;
 612 }
 613
 614 /**
 615  * leb_read_lock - lock a logical eraseblock for read
 616  * @ebh: chfs eraseblock handler
 617  * @lnr: identifier of the logical eraseblock
 618  *
 619  * Returns zero in case of success, error code in case of fail.
 620  */
 621 static int
 622 leb_read_lock(struct chfs_ebh *ebh, int lnr)
 623 {
 624         struct chfs_ltree_entry *le;
 625
 626         le = ltree_add_entry(ebh, lnr);
 627         if (!le)
 628                 return ENOMEM;
 629
 630         rw_enter(&le->mutex, RW_READER);
 631         return 0;
 632 }
 633
 634 /**
 635  * leb_read_unlock - unlock a logical eraseblock from read
 636  * @ebh: chfs eraseblock handler
 637  * @lnr: identifier of the logical eraseblock
 638  *
 639  * This function unlocks a logical eraseblock from read and delete it from the
 640  * lock tree is there are no more users of it.
 641  */
 642 static void
 643 leb_read_unlock(struct chfs_ebh *ebh, int lnr)
 644 {
 645         struct chfs_ltree_entry *le;
 646
 647         mutex_enter(&ebh->ltree_lock);
 648         //dbg_ebh("LOCK: ebh->ltree_lock spin locked in leb_read_unlock()\n");
 649         le = ltree_lookup(ebh, lnr);
 650         if (!le)
 651                 goto out;
 652
 653         le->users -= 1;
 654         KASSERT(le->users >= 0);
 655         rw_exit(&le->mutex);
 656         if (le->users == 0) {
 657                 le = RB_REMOVE(ltree_rbtree, &ebh->ltree, le);
 658                 if (le) {
 659                         KASSERT(!rw_lock_held(&le->mutex));
 660                         rw_destroy(&le->mutex);
 661
 662                         kmem_free(le, sizeof(struct chfs_ltree_entry));
 663                 }
 664         }
 665
 666 out:
 667         mutex_exit(&ebh->ltree_lock);
 668         //dbg_ebh("UNLOCK: ebh->ltree_lock spin unlocked in leb_read_unlock()\n");
 669 }
 670
 671 /**
 672  * leb_write_lock - lock a logical eraseblock for write
 673  * @ebh: chfs eraseblock handler
 674  * @lnr: identifier of the logical eraseblock
 675  *
 676  * Returns zero in case of success, error code in case of fail.
 677  */
 678 static int
 679 leb_write_lock(struct chfs_ebh *ebh, int lnr)
 680 {
 681         struct chfs_ltree_entry *le;
 682
 683         le = ltree_add_entry(ebh, lnr);
 684         if (!le)
 685                 return ENOMEM;
 686
 687         rw_enter(&le->mutex, RW_WRITER);
 688         return 0;
 689 }
 690
 691 /**
 692  * leb_write_unlock - unlock a logical eraseblock from write
 693  * @ebh: chfs eraseblock handler
 694  * @lnr: identifier of the logical eraseblock
 695  *
 696  * This function unlocks a logical eraseblock from write and delete it from the
 697  * lock tree is there are no more users of it.
 698  */
 699 static void
 700 leb_write_unlock(struct chfs_ebh *ebh, int lnr)
 701 {
 702         struct chfs_ltree_entry *le;
 703
 704         mutex_enter(&ebh->ltree_lock);
 705         //dbg_ebh("LOCK: ebh->ltree_lock spin locked in leb_write_unlock()\n");
 706         le = ltree_lookup(ebh, lnr);
 707         if (!le)
 708                 goto out;
 709
 710         le->users -= 1;
 711         KASSERT(le->users >= 0);
 712         rw_exit(&le->mutex);
 713         if (le->users == 0) {
 714                 RB_REMOVE(ltree_rbtree, &ebh->ltree, le);
 715
 716                 KASSERT(!rw_lock_held(&le->mutex));
 717                 rw_destroy(&le->mutex);
 718
 719                 kmem_free(le, sizeof(struct chfs_ltree_entry));
 720         }
 721
 722 out:
 723         mutex_exit(&ebh->ltree_lock);
 724         //dbg_ebh("UNLOCK: ebh->ltree_lock spin unlocked in leb_write_unlock()\n");
 725 }
 726
 727 /*****************************************************************************/
 728 /* End of Lock Tree                                                          */
 729 /*****************************************************************************/
 730
 731 /*****************************************************************************/
 732 /* Erase related operations                                                  */
 733 /*****************************************************************************/
 734
 735 /**
 736  * If the first argument is smaller than the second, the function
 737  * returns a value smaller than zero. If they are equal, the function re-
 738  * turns zero. Otherwise, it should return a value greater than zero.
 739  */
 740 int
 741 peb_in_use_cmp(struct chfs_peb *peb1, struct chfs_peb *peb2)
 742 {
 743         return (peb1->pebnr - peb2->pebnr);
 744 }
 745
 746 int
 747 peb_free_cmp(struct chfs_peb *peb1, struct chfs_peb *peb2)
 748 {
 749         int comp;
 750
 751         comp = peb1->erase_cnt - peb2->erase_cnt;
 752         if (0 == comp)
 753                 comp = peb1->pebnr - peb2->pebnr;
 754
 755         return comp;
 756 }
 757
 758 /* Generate functions for in use PEB's red-black tree */
 759 RB_PROTOTYPE(peb_in_use_rbtree, chfs_peb, u.rb, peb_in_use_cmp);
 760 RB_GENERATE(peb_in_use_rbtree, chfs_peb, u.rb, peb_in_use_cmp);
 761 RB_PROTOTYPE(peb_free_rbtree, chfs_peb, u.rb, peb_free_cmp);
 762 RB_GENERATE(peb_free_rbtree, chfs_peb, u.rb, peb_free_cmp);
 763
 764 /**
 765  * add_peb_to_erase_queue: adds a PEB to to_erase/fully_erased queue
 766  * @ebh - chfs eraseblock handler
 767  * @pebnr - physical eraseblock's number
 768  * @ec - erase counter of PEB
 769  * @queue: the queue to add to
 770  *
 771  * This function adds a PEB to the erase queue specified by @queue.
 772  * The @ebh->erase_lock must be locked before using this.
 773  * Returns zero in case of success, error code in case of fail.
 774  */
 775 int
 776 add_peb_to_erase_queue(struct chfs_ebh *ebh, int pebnr, int ec,
 777     struct peb_queue *queue)
 778 {
 779         struct chfs_peb *peb;
 780
 781         peb = kmem_alloc(sizeof(struct chfs_peb), KM_SLEEP);
 782
 783         peb->erase_cnt = ec;
 784         peb->pebnr = pebnr;
 785
 786         TAILQ_INSERT_TAIL(queue, peb, u.queue);
 787
 788         return 0;
 789
 790 }
 791 //TODO
 792 /**
 793  * find_peb_in_use - looks up a PEB in the RB-tree of used blocks
 794  * @ebh - chfs eraseblock handler
 795  *
 796  * This function returns a pointer to the PEB found in the tree,
 797  * NULL otherwise.
 798  * The @ebh->erase_lock must be locked before using this.
 799  */
 800 struct chfs_peb *
 801 find_peb_in_use(struct chfs_ebh *ebh, int pebnr)
 802 {
 803         struct chfs_peb peb, *result;
 804         peb.pebnr = pebnr;
 805         result = RB_FIND(peb_in_use_rbtree, &ebh->in_use, &peb);
 806         return result;
 807 }
 808
 809 /**
 810  * add_peb_to_free - adds a PEB to the RB-tree of free PEBs
 811  * @ebh - chfs eraseblock handler
 812  * @pebnr - physical eraseblock's number
 813  * @ec - erase counter of PEB
 814  *
 815  *
 816  * This function adds a physical eraseblock to the RB-tree of free PEBs
 817  * stored in the @ebh. The key is the erase counter and pebnr.
 818  * The @ebh->erase_lock must be locked before using this.
 819  * Returns zero in case of success, error code in case of fail.
 820  */
 821 int
 822 add_peb_to_free(struct chfs_ebh *ebh, int pebnr, int ec)
 823 {
 824         struct chfs_peb *peb, *result;
 825
 826         peb = kmem_alloc(sizeof(struct chfs_peb), KM_SLEEP);
 827
 828         peb->erase_cnt = ec;
 829         peb->pebnr = pebnr;
 830         result = RB_INSERT(peb_free_rbtree, &ebh->free, peb);
 831         if (result) {
 832                 kmem_free(peb, sizeof(struct chfs_peb));
 833                 return 1;
 834         }
 835
 836         return 0;
 837 }
 838
 839 /**
 840  * add_peb_to_in_use - adds a PEB to the RB-tree of used PEBs
 841  * @ebh - chfs eraseblock handler
 842  * @pebnr - physical eraseblock's number
 843  * @ec - erase counter of PEB
 844  *
 845  *
 846  * This function adds a physical eraseblock to the RB-tree of used PEBs
 847  * stored in the @ebh. The key is pebnr.
 848  * The @ebh->erase_lock must be locked before using this.
 849  * Returns zero in case of success, error code in case of fail.
 850  */
 851 int
 852 add_peb_to_in_use(struct chfs_ebh *ebh, int pebnr, int ec)
 853 {
 854         struct chfs_peb *peb, *result;
 855
 856         peb = kmem_alloc(sizeof(struct chfs_peb), KM_SLEEP);
 857
 858         peb->erase_cnt = ec;
 859         peb->pebnr = pebnr;
 860         result = RB_INSERT(peb_in_use_rbtree, &ebh->in_use, peb);
 861         if (result) {
 862                 kmem_free(peb, sizeof(struct chfs_peb));
 863                 return 1;
 864         }
 865
 866         return 0;
 867 }
 868
 869 /**
 870  * erase_callback - callback function for flash erase
 871  * @ei: erase information
 872  */
 873 void
 874 erase_callback(struct flash_erase_instruction *ei)
 875 {
 876         int err;
 877         struct chfs_erase_info_priv *priv = (void *) ei->ei_priv;
 878         //dbg_ebh("ERASE_CALLBACK() CALLED\n");
 879         struct chfs_ebh *ebh = priv->ebh;
 880         struct chfs_peb *peb = priv->peb;
 881
 882         peb->erase_cnt += 1;
 883
 884         if (ei->ei_state == FLASH_ERASE_DONE) {
 885
 886                 /* Write out erase counter */
 887                 err = ebh->ops->mark_eb_hdr_free(ebh,
 888                     peb->pebnr, peb->erase_cnt);
 889                 if (err) {
 890                         /* cannot mark PEB as free,so erase it again */
 891                         chfs_err(
 892                                 "cannot mark eraseblock as free, PEB: %d\n",
 893                                 peb->pebnr);
 894                         mutex_enter(&ebh->erase_lock);
 895                         /*dbg_ebh("LOCK: ebh->erase_lock spin locked in erase_callback() "
 896                           "after mark ebhdr free\n");*/
 897                         add_peb_to_erase_queue(ebh, peb->pebnr, peb->erase_cnt,
 898                             &ebh->to_erase);
 899                         mutex_exit(&ebh->erase_lock);
 900                         /*dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in erase_callback() "
 901                           "after mark ebhdr free\n");*/
 902                         kmem_free(peb, sizeof(struct chfs_peb));
 903                         return;
 904                 }
 905
 906                 mutex_enter(&ebh->erase_lock);
 907                 /*dbg_ebh("LOCK: ebh->erase_lock spin locked in erase_callback()\n");*/
 908                 err = add_peb_to_free(ebh, peb->pebnr, peb->erase_cnt);
 909                 mutex_exit(&ebh->erase_lock);
 910                 /*dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in erase_callback()\n");*/
 911                 kmem_free(peb, sizeof(struct chfs_peb));
 912         } else {
 913                 /*
 914                  * Erase is finished, but there was a problem,
 915                  * so erase PEB again
 916                  */
 917                 chfs_err("erase failed, state is: 0x%x\n", ei->ei_state);
 918                 add_peb_to_erase_queue(ebh, peb->pebnr, peb->erase_cnt, &ebh->to_erase);
 919                 kmem_free(peb, sizeof(struct chfs_peb));
 920         }
 921 }
 922
 923 /**
 924  * free_peb: free a PEB
 925  * @ebh: chfs eraseblock handler
 926  *
 927  * This function erases the first physical eraseblock from one of the erase
 928  * lists and adds to the RB-tree of free PEBs.
 929  * Returns zero in case of succes, error code in case of fail.
 930  */
 931 int
 932 free_peb(struct chfs_ebh *ebh)
 933 {
 934         int err, retries = 0;
 935         off_t ofs;
 936         struct chfs_peb *peb = NULL;
 937         struct flash_erase_instruction *ei;
 938
 939         KASSERT(mutex_owned(&ebh->erase_lock));
 940
 941         if (!TAILQ_EMPTY(&ebh->fully_erased)) {
 942                 //dbg_ebh("[FREE PEB] got a fully erased block\n");
 943                 peb = TAILQ_FIRST(&ebh->fully_erased);
 944                 TAILQ_REMOVE(&ebh->fully_erased, peb, u.queue);
 945                 err = ebh->ops->mark_eb_hdr_free(ebh,
 946                     peb->pebnr, peb->erase_cnt);
 947                 if (err) {
 948                         goto out_free;
 949                 }
 950                 err = add_peb_to_free(ebh, peb->pebnr, peb->erase_cnt);
 951                 goto out_free;
 952         }
 953         /* Erase PEB */
 954         //dbg_ebh("[FREE PEB] eraseing a block\n");
 955         peb = TAILQ_FIRST(&ebh->to_erase);
 956         TAILQ_REMOVE(&ebh->to_erase, peb, u.queue);
 957         mutex_exit(&ebh->erase_lock);
 958         //dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in free_peb()\n");
 959         ofs = peb->pebnr * ebh->flash_if->erasesize;
 960
 961         /* XXX where do we free this? */
 962         ei = kmem_alloc(sizeof(struct flash_erase_instruction)
 963             + sizeof(struct chfs_erase_info_priv), KM_SLEEP);
 964 retry:
 965         memset(ei, 0, sizeof(*ei));
 966
 967 //      ei->ei_if = ebh->flash_if;
 968         ei->ei_addr = ofs;
 969         ei->ei_len = ebh->flash_if->erasesize;
 970         ei->ei_callback = erase_callback;
 971         ei->ei_priv = (unsigned long) (&ei[1]);
 972
 973         ((struct chfs_erase_info_priv *) ei->ei_priv)->ebh = ebh;
 974         ((struct chfs_erase_info_priv *) ei->ei_priv)->peb = peb;
 975
 976         err = flash_erase(ebh->flash_dev, ei);
 977         dbg_ebh("erased peb: %d\n", peb->pebnr);
 978
 979         /* einval would mean we did something wrong */
 980         KASSERT(err != EINVAL);
 981
 982         if (err) {
 983                 dbg_ebh("errno: %d, ei->ei_state: %d\n", err, ei->ei_state);
 984                 if (CHFS_MAX_GET_PEB_RETRIES < ++retries &&
 985                     ei->ei_state == FLASH_ERASE_FAILED) {
 986                         /* The block went bad mark it */
 987                         dbg_ebh("ebh markbad! 0x%jx\n", (uintmax_t )ofs);
 988                         err = flash_block_markbad(ebh->flash_dev, ofs);
 989                         if (!err) {
 990                                 ebh->peb_nr--;
 991                         }
 992
 993                         goto out;
 994                 }
 995                 chfs_err("can not erase PEB: %d, try again\n", peb->pebnr);
 996                 goto retry;
 997         }
 998
 999 out:
1000         /* lock the erase_lock, because it was locked
1001          * when the function was called */
1002         mutex_enter(&ebh->erase_lock);
1003         return err;
1004
1005 out_free:
1006         kmem_free(peb, sizeof(struct chfs_peb));
1007         return err;
1008 }
1009
1010 /**
1011  * release_peb - schedule an erase for the PEB
1012  * @ebh: chfs eraseblock handler
1013  * @pebnr: physical eraseblock number
1014  *
1015  * This function get the peb identified by @pebnr from the in_use RB-tree of
1016  * @ebh, removes it and schedule an erase for it.
1017  *
1018  * Returns zero on success, error code in case of fail.
1019  */
1020 int
1021 release_peb(struct chfs_ebh *ebh, int pebnr)
1022 {
1023         int err = 0;
1024         struct chfs_peb *peb;
1025
1026         mutex_enter(&ebh->erase_lock);
1027
1028         //dbg_ebh("LOCK: ebh->erase_lock spin locked in release_peb()\n");
1029         peb = find_peb_in_use(ebh, pebnr);
1030         if (!peb) {
1031                 chfs_err("LEB is mapped, but is not in the 'in_use' "
1032                     "tree of ebh\n");
1033                 goto out_unlock;
1034         }
1035         err = add_peb_to_erase_queue(ebh, peb->pebnr, peb->erase_cnt,
1036             &ebh->to_erase);
1037
1038         if (err)
1039                 goto out_unlock;
1040
1041         RB_REMOVE(peb_in_use_rbtree, &ebh->in_use, peb);
1042 out_unlock:
1043         mutex_exit(&ebh->erase_lock);
1044         //dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in release_peb()"
1045         //              " at out_unlock\n");
1046         return err;
1047 }
1048
1049 /**
1050  * erase_thread - background thread for erasing PEBs
1051  * @data: pointer to the eraseblock handler
1052  */
1053 /*void
1054   erase_thread(void *data)
1055   {
1056   struct chfs_ebh *ebh = data;
1057
1058   dbg_ebh("erase thread started\n");
1059   while (ebh->bg_erase.eth_running) {
1060   int err;
1061
1062   mutex_enter(&ebh->erase_lock);
1063   dbg_ebh("LOCK: ebh->erase_lock spin locked in erase_thread()\n");
1064   if (TAILQ_EMPTY(&ebh->to_erase) && TAILQ_EMPTY(&ebh->fully_erased)) {
1065   dbg_ebh("thread has nothing to do\n");
1066   mutex_exit(&ebh->erase_lock);
1067   mutex_enter(&ebh->bg_erase.eth_thread_mtx);
1068   cv_timedwait_sig(&ebh->bg_erase.eth_wakeup,
1069   &ebh->bg_erase.eth_thread_mtx, mstohz(100));
1070   mutex_exit(&ebh->bg_erase.eth_thread_mtx);
1071
1072   dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in erase_thread()\n");
1073   continue;
1074   }
1075   mutex_exit(&ebh->erase_lock);
1076   dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in erase_thread()\n");
1077
1078   err = free_peb(ebh);
1079   if (err)
1080   chfs_err("freeing PEB failed in the background thread: %d\n", err);
1081
1082   }
1083   dbg_ebh("erase thread stopped\n");
1084   kthread_exit(0);
1085   }*/
1086
1087 /**
1088  * erase_thread - background thread for erasing PEBs
1089  * @data: pointer to the eraseblock handler
1090  */
1091 void
1092 erase_thread(void *data) {
1093         dbg_ebh("[EBH THREAD] erase thread started\n");
1094
1095         struct chfs_ebh *ebh = data;
1096         int err;
1097
1098         mutex_enter(&ebh->erase_lock);
1099         while (ebh->bg_erase.eth_running) {
1100                 if (TAILQ_EMPTY(&ebh->to_erase) &&
1101                     TAILQ_EMPTY(&ebh->fully_erased)) {
1102                         cv_timedwait_sig(&ebh->bg_erase.eth_wakeup,
1103                             &ebh->erase_lock, mstohz(100));
1104                 } else {
1105                         /* XXX exiting this mutex is a bit odd here as
1106                          * free_peb instantly reenters it...
1107                          */
1108                         err = free_peb(ebh);
1109                         mutex_exit(&ebh->erase_lock);
1110                         if (err) {
1111                                 chfs_err("freeing PEB failed in the"
1112                                     " background thread: %d\n", err);
1113                         }
1114                         mutex_enter(&ebh->erase_lock);
1115                 }
1116         }
1117         mutex_exit(&ebh->erase_lock);
1118
1119         dbg_ebh("[EBH THREAD] erase thread stopped\n");
1120         kthread_exit(0);
1121 }
1122
1123 /**
1124  * erase_thread_start - init and start erase thread
1125  * @ebh: eraseblock handler
1126  */
1127 static void
1128 erase_thread_start(struct chfs_ebh *ebh)
1129 {
1130         cv_init(&ebh->bg_erase.eth_wakeup, "ebheracv");
1131
1132         ebh->bg_erase.eth_running = true;
1133         kthread_create(PRI_NONE, KTHREAD_MPSAFE | KTHREAD_MUSTJOIN, NULL,
1134             erase_thread, ebh, &ebh->bg_erase.eth_thread, "ebherase");
1135 }
1136
1137 /**
1138  * erase_thread_stop - stop background erase thread
1139  * @ebh: eraseblock handler
1140  */
1141 static void
1142 erase_thread_stop(struct chfs_ebh *ebh)
1143 {
1144         ebh->bg_erase.eth_running = false;
1145         cv_signal(&ebh->bg_erase.eth_wakeup);
1146         dbg_ebh("[EBH THREAD STOP] signaled\n");
1147
1148         kthread_join(ebh->bg_erase.eth_thread);
1149 #ifdef BROKEN_KTH_JOIN
1150         kpause("chfsebhjointh", false, mstohz(1000), NULL);
1151 #endif
1152
1153         cv_destroy(&ebh->bg_erase.eth_wakeup);
1154 }
1155
1156 /*****************************************************************************/
1157 /* End of Erase related operations                                           */
1158 /*****************************************************************************/
1159
1160 /*****************************************************************************/
1161 /* Scan related operations                                                   */
1162 /*****************************************************************************/
1163 int
1164 scan_leb_used_cmp(struct chfs_scan_leb *sleb1, struct chfs_scan_leb *sleb2)
1165 {
1166         return (sleb1->lnr - sleb2->lnr);
1167 }
1168
1169 RB_PROTOTYPE(scan_leb_used_rbtree, chfs_scan_leb, u.rb, scan_leb_used_cmp);
1170 RB_GENERATE(scan_leb_used_rbtree, chfs_scan_leb, u.rb, scan_leb_used_cmp);
1171
1172 /**
1173  * scan_add_to_queue - adds a physical eraseblock to one of the
1174  *                     eraseblock queue
1175  * @si: chfs scanning information
1176  * @pebnr: physical eraseblock number
1177  * @erase_cnt: erase counter of the physical eraseblock
1178  * @list: the list to add to
1179  *
1180  * This function adds a physical eraseblock to one of the lists in the scanning
1181  * information.
1182  * Returns zero in case of success, negative error code in case of fail.
1183  */
1184 static int
1185 scan_add_to_queue(struct chfs_scan_info *si, int pebnr, int erase_cnt,
1186     struct scan_leb_queue *queue)
1187 {
1188         struct chfs_scan_leb *sleb;
1189
1190         sleb = kmem_alloc(sizeof(struct chfs_scan_leb), KM_SLEEP);
1191
1192         sleb->pebnr = pebnr;
1193         sleb->erase_cnt = erase_cnt;
1194         TAILQ_INSERT_TAIL(queue, sleb, u.queue);
1195         return 0;
1196 }
1197
1198 /*
1199  * nor_scan_add_to_used - add a physical eraseblock to the
1200  *                        used tree of scan info
1201  * @ebh: chfs eraseblock handler
1202  * @si: chfs scanning information
1203  * @ebhdr: eraseblock header
1204  * @pebnr: physical eraseblock number
1205  * @leb_status: the status of the PEB's eraseblock header
1206  *
1207  * This function adds a PEB to the used tree of the scanning information.
1208  * It handles the situations if there are more physical eraseblock referencing
1209  * to the same logical eraseblock.
1210  * Returns zero in case of success, error code in case of fail.
1211  */
1212 int
1213 nor_scan_add_to_used(struct chfs_ebh *ebh, struct chfs_scan_info *si,
1214     struct chfs_eb_hdr *ebhdr, int pebnr, int leb_status)
1215 {
1216         int err, lnr, ec;
1217         struct chfs_scan_leb *sleb, *old;
1218
1219         lnr = CHFS_GET_LID(ebhdr->u.nor_hdr.lid);
1220         ec = le32toh(ebhdr->ec_hdr.erase_cnt);
1221
1222         sleb = kmem_alloc(sizeof(struct chfs_scan_leb), KM_SLEEP);
1223
1224         sleb->erase_cnt = ec;
1225         sleb->lnr = lnr;
1226         sleb->pebnr = pebnr;
1227         sleb->info = leb_status;
1228
1229         old = RB_INSERT(scan_leb_used_rbtree, &si->used, sleb);
1230         if (old) {
1231                 kmem_free(sleb, sizeof(struct chfs_scan_leb));
1232                 /* There is already an eraseblock in the used tree */
1233                 /* If the new one is bad */
1234                 if (EBHDR_LEB_DIRTY == leb_status &&
1235                     EBHDR_LEB_OK == old->info) {
1236                         return scan_add_to_queue(si, pebnr, ec, &si->erase);
1237                 } else {
1238                         err = scan_add_to_queue(si, old->pebnr,
1239                             old->erase_cnt, &si->erase);
1240                         if (err) {
1241                                 return err;
1242                         }
1243
1244                         old->erase_cnt = ec;
1245                         old->lnr = lnr;
1246                         old->pebnr = pebnr;
1247                         old->info = leb_status;
1248                         return 0;
1249                 }
1250         }
1251         return 0;
1252 }
1253
1254 /**
1255  * nor_process eb -read the headers from NOR flash, check them and add to
1256  *                                 the scanning information
1257  * @ebh: chfs eraseblock handler
1258  * @si: chfs scanning information
1259  * @pebnr: physical eraseblock number
1260  *
1261  * Returns zero in case of success, error code in case of fail.
1262  */
1263 int
1264 nor_process_eb(struct chfs_ebh *ebh, struct chfs_scan_info *si,
1265     int pebnr, struct chfs_eb_hdr *ebhdr)
1266 {
1267         int err, erase_cnt, leb_status;
1268
1269         err = ebh->ops->read_eb_hdr(ebh, pebnr, ebhdr);
1270         if (err)
1271                 return err;
1272
1273         erase_cnt = le32toh(ebhdr->ec_hdr.erase_cnt);
1274         dbg_ebh("erase_cnt: %d\n", erase_cnt);
1275         leb_status = ebh->ops->check_eb_hdr(ebh, ebhdr);
1276         if (EBHDR_LEB_BADMAGIC == leb_status ||
1277             EBHDR_LEB_BADCRC == leb_status) {
1278                 err = scan_add_to_queue(si, pebnr, erase_cnt, &si->corrupted);
1279                 return err;
1280         }
1281         else if (EBHDR_LEB_FREE == leb_status) {
1282                 err = scan_add_to_queue(si, pebnr, erase_cnt, &si->free);
1283                 goto count_mean;
1284         }
1285         else if (EBHDR_LEB_NO_HDR == leb_status) {
1286                 err = scan_add_to_queue(si, pebnr, erase_cnt, &si->erased);
1287                 return err;
1288         }
1289         else if (EBHDR_LEB_INVALIDATED == leb_status) {
1290                 err = scan_add_to_queue(si, pebnr, erase_cnt, &si->erase);
1291                 return err;
1292         }
1293
1294         err = nor_scan_add_to_used(ebh, si, ebhdr, pebnr, leb_status);
1295         if (err)
1296                 return err;
1297
1298
1299 count_mean:
1300         si->sum_of_ec += erase_cnt;
1301         si->num_of_eb++;
1302
1303         return err;
1304 }
1305
1306 /*
1307  * nand_scan_add_to_used - add a physical eraseblock to the
1308  *                         used tree of scan info
1309  * @ebh: chfs eraseblock handler
1310  * @si: chfs scanning information
1311  * @ebhdr: eraseblock header
1312  * @pebnr: physical eraseblock number
1313  * @leb_status: the status of the PEB's eraseblock header
1314  *
1315  * This function adds a PEB to the used tree of the scanning information.
1316  * It handles the situations if there are more physical eraseblock referencing
1317  * to the same logical eraseblock.
1318  * Returns zero in case of success, error code in case of fail.
1319  */
1320 int
1321 nand_scan_add_to_used(struct chfs_ebh *ebh, struct chfs_scan_info *si,
1322     struct chfs_eb_hdr *ebhdr, int pebnr)
1323 {
1324         int err, lnr, ec;
1325         struct chfs_scan_leb *sleb, *old;
1326         uint64_t serial = le64toh(ebhdr->u.nand_hdr.serial);
1327
1328         lnr = CHFS_GET_LID(ebhdr->u.nor_hdr.lid);
1329         ec = le32toh(ebhdr->ec_hdr.erase_cnt);
1330
1331         sleb = kmem_alloc(sizeof(struct chfs_scan_leb), KM_SLEEP);
1332
1333         sleb->erase_cnt = ec;
1334         sleb->lnr = lnr;
1335         sleb->pebnr = pebnr;
1336         sleb->info = serial;
1337
1338         old = RB_INSERT(scan_leb_used_rbtree, &si->used, sleb);
1339         if (old) {
1340                 kmem_free(sleb, sizeof(struct chfs_scan_leb));
1341                 /* There is already an eraseblock in the used tree */
1342                 /* If the new one is bad */
1343                 if (serial < old->info)
1344                         return scan_add_to_queue(si, pebnr, ec, &si->erase);
1345                 else {
1346                         err = scan_add_to_queue(si,
1347                             old->pebnr, old->erase_cnt, &si->erase);
1348                         if (err)
1349                                 return err;
1350
1351                         old->erase_cnt = ec;
1352                         old->lnr = lnr;
1353                         old->pebnr = pebnr;
1354                         old->info = serial;
1355                         return 0;
1356                 }
1357         }
1358         return 0;
1359 }
1360
1361 /**
1362  * nand_process eb -read the headers from NAND flash, check them and add to the
1363  *                                      scanning information
1364  * @ebh: chfs eraseblock handler
1365  * @si: chfs scanning information
1366  * @pebnr: physical eraseblock number
1367  *
1368  * Returns zero in case of success, error code in case of fail.
1369  */
1370 int
1371 nand_process_eb(struct chfs_ebh *ebh, struct chfs_scan_info *si,
1372     int pebnr, struct chfs_eb_hdr *ebhdr)
1373 {
1374         int err, erase_cnt, leb_status;
1375         uint64_t max_serial;
1376         /* isbad() is defined on some ancient platforms, heh */
1377         bool is_bad;
1378
1379         /* Check block is bad */
1380         err = flash_block_isbad(ebh->flash_dev,
1381             pebnr * ebh->flash_if->erasesize, &is_bad);
1382         if (err) {
1383                 chfs_err("checking block is bad failed\n");
1384                 return err;
1385         }
1386         if (is_bad) {
1387                 si->bad_peb_cnt++;
1388                 return 0;
1389         }
1390
1391         err = ebh->ops->read_eb_hdr(ebh, pebnr, ebhdr);
1392         if (err)
1393                 return err;
1394
1395         erase_cnt = le32toh(ebhdr->ec_hdr.erase_cnt);
1396         leb_status = ebh->ops->check_eb_hdr(ebh, ebhdr);
1397         if (EBHDR_LEB_BADMAGIC == leb_status ||
1398             EBHDR_LEB_BADCRC == leb_status) {
1399                 err = scan_add_to_queue(si, pebnr, erase_cnt, &si->corrupted);
1400                 return err;
1401         }
1402         else if (EBHDR_LEB_FREE == leb_status) {
1403                 err = scan_add_to_queue(si, pebnr, erase_cnt, &si->free);
1404                 goto count_mean;
1405         }
1406         else if (EBHDR_LEB_NO_HDR == leb_status) {
1407                 err = scan_add_to_queue(si, pebnr, erase_cnt, &si->erased);
1408                 return err;
1409         }
1410
1411         err = nand_scan_add_to_used(ebh, si, ebhdr, pebnr);
1412         if (err)
1413                 return err;
1414
1415         max_serial = le64toh(ebhdr->u.nand_hdr.serial);
1416         if (max_serial > *ebh->max_serial) {
1417                 *ebh->max_serial = max_serial;
1418         }
1419
1420 count_mean:
1421         si->sum_of_ec += erase_cnt;
1422         si->num_of_eb++;
1423
1424         return err;
1425 }
1426
1427 /**
1428  * chfs_scan - scans the media and returns informations about it
1429  * @ebh: chfs eraseblock handler
1430  *
1431  * This function scans through the media and returns information about it or if
1432  * it fails NULL will be returned.
1433  */
1434 struct chfs_scan_info *
1435 chfs_scan(struct chfs_ebh *ebh)
1436 {
1437         struct chfs_scan_info *si;
1438         struct chfs_eb_hdr *ebhdr;
1439         int pebnr, err;
1440
1441         si = kmem_alloc(sizeof(*si), KM_SLEEP);
1442
1443         TAILQ_INIT(&si->corrupted);
1444         TAILQ_INIT(&si->free);
1445         TAILQ_INIT(&si->erase);
1446         TAILQ_INIT(&si->erased);
1447         RB_INIT(&si->used);
1448         si->bad_peb_cnt = 0;
1449         si->num_of_eb = 0;
1450         si->sum_of_ec = 0;
1451
1452         ebhdr = kmem_alloc(sizeof(*ebhdr), KM_SLEEP);
1453
1454         for (pebnr = 0; pebnr < ebh->peb_nr; pebnr++) {
1455                 dbg_ebh("processing PEB %d\n", pebnr);
1456                 err = ebh->ops->process_eb(ebh, si, pebnr, ebhdr);
1457                 if (err < 0)
1458                         goto out_ebhdr;
1459         }
1460         kmem_free(ebhdr, sizeof(*ebhdr));
1461         dbg_ebh("[CHFS_SCAN] scanning information collected\n");
1462         return si;
1463
1464 out_ebhdr:
1465         kmem_free(ebhdr, sizeof(*ebhdr));
1466         kmem_free(si, sizeof(*si));
1467         return NULL;
1468 }
1469
1470 /**
1471  * scan_info_destroy - frees all lists and trees in the scanning information
1472  * @si: the scanning information
1473  */
1474 void
1475 scan_info_destroy(struct chfs_scan_info *si)
1476 {
1477         EBH_QUEUE_DESTROY(&si->corrupted,
1478             struct chfs_scan_leb, u.queue);
1479
1480         EBH_QUEUE_DESTROY(&si->erase,
1481             struct chfs_scan_leb, u.queue);
1482
1483         EBH_QUEUE_DESTROY(&si->erased,
1484             struct chfs_scan_leb, u.queue);
1485
1486         EBH_QUEUE_DESTROY(&si->free,
1487             struct chfs_scan_leb, u.queue);
1488
1489         EBH_TREE_DESTROY(scan_leb_used_rbtree,
1490             &si->used, struct chfs_scan_leb);
1491
1492         kmem_free(si, sizeof(*si));
1493         dbg_ebh("[SCAN_INFO_DESTROY] scanning information destroyed\n");
1494 }
1495
1496 /**
1497  * scan_media - scan media
1498  *
1499  * @ebh - chfs eraseblock handler
1500  *
1501  * Returns zero in case of success, error code in case of fail.
1502  */
1503
1504 int
1505 scan_media(struct chfs_ebh *ebh)
1506 {
1507         int err, i, avg_ec;
1508         struct chfs_scan_info *si;
1509         struct chfs_scan_leb *sleb;
1510
1511         si = chfs_scan(ebh);
1512         /*
1513          * Process the scan info, manage the eraseblock lists
1514          */
1515         mutex_init(&ebh->ltree_lock, MUTEX_DEFAULT, IPL_NONE);
1516         mutex_init(&ebh->erase_lock, MUTEX_DEFAULT, IPL_NONE);
1517         RB_INIT(&ebh->ltree);
1518         RB_INIT(&ebh->free);
1519         RB_INIT(&ebh->in_use);
1520         TAILQ_INIT(&ebh->to_erase);
1521         TAILQ_INIT(&ebh->fully_erased);
1522         mutex_init(&ebh->alc_mutex, MUTEX_DEFAULT, IPL_NONE);
1523
1524         ebh->peb_nr -= si->bad_peb_cnt;
1525
1526         /*
1527          * Create background thread for erasing
1528          */
1529         erase_thread_start(ebh);
1530
1531         ebh->lmap = kmem_alloc(ebh->peb_nr * sizeof(int), KM_SLEEP);
1532
1533         for (i = 0; i < ebh->peb_nr; i++) {
1534                 ebh->lmap[i] = EBH_LEB_UNMAPPED;
1535         }
1536
1537         if (si->num_of_eb == 0) {
1538                 /* The flash contains no data. */
1539                 avg_ec = 0;
1540         }
1541         else {
1542                 avg_ec = (int) (si->sum_of_ec / si->num_of_eb);
1543         }
1544         dbg_ebh("num_of_eb: %d\n", si->num_of_eb);
1545
1546         mutex_enter(&ebh->erase_lock);
1547
1548         RB_FOREACH(sleb, scan_leb_used_rbtree, &si->used) {
1549                 ebh->lmap[sleb->lnr] = sleb->pebnr;
1550                 err = add_peb_to_in_use(ebh, sleb->pebnr, sleb->erase_cnt);
1551                 if (err)
1552                         goto out_free;
1553         }
1554
1555         TAILQ_FOREACH(sleb, &si->erased, u.queue) {
1556                 err = add_peb_to_erase_queue(ebh, sleb->pebnr, avg_ec,
1557                     &ebh->fully_erased);
1558                 if (err)
1559                         goto out_free;
1560         }
1561
1562         TAILQ_FOREACH(sleb, &si->erase, u.queue) {
1563                 err = add_peb_to_erase_queue(ebh, sleb->pebnr, avg_ec,
1564                     &ebh->to_erase);
1565                 if (err)
1566                         goto out_free;
1567         }
1568
1569         TAILQ_FOREACH(sleb, &si->free, u.queue) {
1570                 err = add_peb_to_free(ebh, sleb->pebnr, sleb->erase_cnt);
1571                 if (err)
1572                         goto out_free;
1573         }
1574
1575         TAILQ_FOREACH(sleb, &si->corrupted, u.queue) {
1576                 err = add_peb_to_erase_queue(ebh, sleb->pebnr, avg_ec,
1577                     &ebh->to_erase);
1578                 if (err)
1579                         goto out_free;
1580         }
1581         mutex_exit(&ebh->erase_lock);
1582         scan_info_destroy(si);
1583         return 0;
1584
1585 out_free:
1586         mutex_exit(&ebh->erase_lock);
1587         kmem_free(ebh->lmap, ebh->peb_nr * sizeof(int));
1588         scan_info_destroy(si);
1589         dbg_ebh("[SCAN_MEDIA] returning with error: %d\n", err);
1590         return err;
1591 }
1592
1593 /*****************************************************************************/
1594 /* End of Scan related operations                                            */
1595 /*****************************************************************************/
1596
1597 /**
1598  * ebh_open - opens mtd device and init ereaseblock header
1599  * @ebh: eraseblock handler
1600  * @flash_nr: flash device number to use
1601  *
1602  * Returns zero in case of success, error code in case of fail.
1603  */
1604 int
1605 ebh_open(struct chfs_ebh *ebh, dev_t dev)
1606 {
1607         int err;
1608
1609         ebh->flash_dev = flash_get_device(dev);
1610         if (!ebh->flash_dev) {
1611                 aprint_error("ebh_open: cant get flash device\n");
1612                 return ENODEV;
1613         }
1614
1615         ebh->flash_if = flash_get_interface(dev);
1616         if (!ebh->flash_if) {
1617                 aprint_error("ebh_open: cant get flash interface\n");
1618                 return ENODEV;
1619         }
1620
1621         ebh->flash_size = flash_get_size(dev);
1622         ebh->peb_nr = ebh->flash_size / ebh->flash_if->erasesize;
1623 //      ebh->peb_nr = ebh->flash_if->size / ebh->flash_if->erasesize;
1624         /* Set up flash operations based on flash type */
1625         ebh->ops = kmem_alloc(sizeof(struct chfs_ebh_ops), KM_SLEEP);
1626
1627         switch (ebh->flash_if->type) {
1628         case FLASH_TYPE_NOR:
1629                 ebh->eb_size = ebh->flash_if->erasesize -
1630                     CHFS_EB_EC_HDR_SIZE - CHFS_EB_HDR_NOR_SIZE;
1631
1632                 ebh->ops->read_eb_hdr = nor_read_eb_hdr;
1633                 ebh->ops->write_eb_hdr = nor_write_eb_hdr;
1634                 ebh->ops->check_eb_hdr = nor_check_eb_hdr;
1635                 ebh->ops->mark_eb_hdr_dirty_flash =
1636                     nor_mark_eb_hdr_dirty_flash;
1637                 ebh->ops->invalidate_eb_hdr = nor_invalidate_eb_hdr;
1638                 ebh->ops->mark_eb_hdr_free = mark_eb_hdr_free;
1639
1640                 ebh->ops->process_eb = nor_process_eb;
1641
1642                 ebh->ops->create_eb_hdr = nor_create_eb_hdr;
1643                 ebh->ops->calc_data_offs = nor_calc_data_offs;
1644
1645                 ebh->max_serial = NULL;
1646                 break;
1647         case FLASH_TYPE_NAND:
1648                 ebh->eb_size = ebh->flash_if->erasesize -
1649                     2 * ebh->flash_if->page_size;
1650
1651                 ebh->ops->read_eb_hdr = nand_read_eb_hdr;
1652                 ebh->ops->write_eb_hdr = nand_write_eb_hdr;
1653                 ebh->ops->check_eb_hdr = nand_check_eb_hdr;
1654                 ebh->ops->mark_eb_hdr_free = mark_eb_hdr_free;
1655                 ebh->ops->mark_eb_hdr_dirty_flash = NULL;
1656                 ebh->ops->invalidate_eb_hdr = NULL;
1657
1658                 ebh->ops->process_eb = nand_process_eb;
1659
1660                 ebh->ops->create_eb_hdr = nand_create_eb_hdr;
1661                 ebh->ops->calc_data_offs = nand_calc_data_offs;
1662
1663                 ebh->max_serial = kmem_alloc(sizeof(uint64_t), KM_SLEEP);
1664
1665                 *ebh->max_serial = 0;
1666                 break;
1667         default:
1668                 return 1;
1669         }
1670         printf("opening ebh: eb_size: %zu\n", ebh->eb_size);
1671         err = scan_media(ebh);
1672         if (err) {
1673                 dbg_ebh("Scan failed.");
1674                 kmem_free(ebh->ops, sizeof(struct chfs_ebh_ops));
1675                 kmem_free(ebh, sizeof(struct chfs_ebh));
1676                 return err;
1677         }
1678         return 0;
1679 }
1680
1681 /**
1682  * ebh_close - close ebh
1683  * @ebh: eraseblock handler
1684  * Returns zero in case of success, error code in case of fail.
1685  */
1686 int
1687 ebh_close(struct chfs_ebh *ebh)
1688 {
1689         erase_thread_stop(ebh);
1690
1691         EBH_TREE_DESTROY(peb_free_rbtree, &ebh->free, struct chfs_peb);
1692         EBH_TREE_DESTROY(peb_in_use_rbtree, &ebh->in_use, struct chfs_peb);
1693
1694         EBH_QUEUE_DESTROY(&ebh->fully_erased, struct chfs_peb, u.queue);
1695         EBH_QUEUE_DESTROY(&ebh->to_erase, struct chfs_peb, u.queue);
1696
1697         /* XXX HACK, see ebh.h */
1698         EBH_TREE_DESTROY_MUTEX(ltree_rbtree, &ebh->ltree,
1699             struct chfs_ltree_entry);
1700
1701         KASSERT(!mutex_owned(&ebh->ltree_lock));
1702         KASSERT(!mutex_owned(&ebh->alc_mutex));
1703         KASSERT(!mutex_owned(&ebh->erase_lock));
1704
1705         mutex_destroy(&ebh->ltree_lock);
1706         mutex_destroy(&ebh->alc_mutex);
1707         mutex_destroy(&ebh->erase_lock);
1708
1709         kmem_free(ebh->ops, sizeof(struct chfs_ebh_ops));
1710         kmem_free(ebh, sizeof(struct chfs_ebh));
1711
1712         return 0;
1713 }
1714
1715 /**
1716  * ebh_read_leb - read data from leb
1717  * @ebh: eraseblock handler
1718  * @lnr: logical eraseblock number
1719  * @buf: buffer to read to
1720  * @offset: offset from where to read
1721  * @len: bytes number to read
1722  *
1723  * Returns zero in case of success, error code in case of fail.
1724  */
1725 int
1726 ebh_read_leb(struct chfs_ebh *ebh, int lnr, char *buf, uint32_t offset,
1727     size_t len, size_t *retlen)
1728 {
1729         int err, pebnr;
1730         off_t data_offset;
1731
1732         KASSERT(offset + len <= ebh->eb_size);
1733
1734         err = leb_read_lock(ebh, lnr);
1735         if (err)
1736                 return err;
1737
1738         pebnr = ebh->lmap[lnr];
1739         /* If PEB is not mapped the buffer is filled with 0xFF */
1740         if (EBH_LEB_UNMAPPED == pebnr) {
1741                 leb_read_unlock(ebh, lnr);
1742                 memset(buf, 0xFF, len);
1743                 return 0;
1744         }
1745
1746         /* Read data */
1747         data_offset = ebh->ops->calc_data_offs(ebh, pebnr, offset);
1748         err = flash_read(ebh->flash_dev, data_offset, len, retlen,
1749             (unsigned char *) buf);
1750         if (err)
1751                 goto out_free;
1752
1753         KASSERT(len == *retlen);
1754
1755 out_free:
1756         leb_read_unlock(ebh, lnr);
1757         return err;
1758 }
1759
1760 /**
1761  * get_peb: get a free physical eraseblock
1762  * @ebh - chfs eraseblock handler
1763  *
1764  * This function gets a free eraseblock from the ebh->free RB-tree.
1765  * The fist entry will be returned and deleted from the tree.
1766  * The entries sorted by the erase counters, so the PEB with the smallest
1767  * erase counter will be added back.
1768  * If something goes bad a negative value will be returned.
1769  */
1770 int
1771 get_peb(struct chfs_ebh *ebh)
1772 {
1773         int err, pebnr;
1774         struct chfs_peb *peb;
1775
1776 retry:
1777         mutex_enter(&ebh->erase_lock);
1778         //dbg_ebh("LOCK: ebh->erase_lock spin locked in get_peb()\n");
1779         if (RB_EMPTY(&ebh->free)) {
1780                 /*There is no more free PEBs in the tree*/
1781                 if (TAILQ_EMPTY(&ebh->to_erase) &&
1782                     TAILQ_EMPTY(&ebh->fully_erased)) {
1783                         mutex_exit(&ebh->erase_lock);
1784                         //dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in get_peb()\n");
1785                         return ENOSPC;
1786                 }
1787                 err = free_peb(ebh);
1788
1789                 mutex_exit(&ebh->erase_lock);
1790                 //dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in get_peb()\n");
1791
1792                 if (err)
1793                         return err;
1794                 goto retry;
1795         }
1796         peb = RB_MIN(peb_free_rbtree, &ebh->free);
1797         pebnr = peb->pebnr;
1798         RB_REMOVE(peb_free_rbtree, &ebh->free, peb);
1799         err = add_peb_to_in_use(ebh, peb->pebnr, peb->erase_cnt);
1800         if (err)
1801                 pebnr = err;
1802
1803         kmem_free(peb, sizeof(struct chfs_peb));
1804
1805         mutex_exit(&ebh->erase_lock);
1806         //dbg_ebh("UNLOCK: ebh->erase_lock spin unlocked in get_peb()\n");
1807
1808         return pebnr;
1809 }
1810
1811 /**
1812  * ebh_write_leb - write data to leb
1813  * @ebh: eraseblock handler
1814  * @lnr: logical eraseblock number
1815  * @buf: data to write
1816  * @offset: offset where to write
1817  * @len: bytes number to write
1818  *
1819  * Returns zero in case of success, error code in case of fail.
1820  */
1821 int
1822 ebh_write_leb(struct chfs_ebh *ebh, int lnr, char *buf, uint32_t offset,
1823     size_t len, size_t *retlen)
1824 {
1825         int err, pebnr, retries = 0;
1826         off_t data_offset;
1827         struct chfs_eb_hdr *ebhdr;
1828
1829         dbg("offset: %d | len: %zu | (offset+len): %zu "
1830             " | ebsize: %zu\n", offset, len, (offset+len), ebh->eb_size);
1831
1832         KASSERT(offset + len <= ebh->eb_size);
1833
1834         err = leb_write_lock(ebh, lnr);
1835         if (err)
1836                 return err;
1837
1838         pebnr = ebh->lmap[lnr];
1839         /* If the LEB is mapped write out data */
1840         if (pebnr != EBH_LEB_UNMAPPED) {
1841                 data_offset = ebh->ops->calc_data_offs(ebh, pebnr, offset);
1842                 err = flash_write(ebh->flash_dev, data_offset, len, retlen,
1843                     (unsigned char *) buf);
1844
1845                 if (err) {
1846                         chfs_err("error %d while writing %zu bytes to PEB "
1847                             "%d:%ju, written %zu bytes\n",
1848                             err, len, pebnr, (uintmax_t )offset, *retlen);
1849                 } else {
1850                         KASSERT(len == *retlen);
1851                 }
1852
1853                 leb_write_unlock(ebh, lnr);
1854                 return err;
1855         }
1856
1857         /*
1858          * If the LEB is unmapped, get a free PEB and write the
1859          * eraseblock header first
1860          */
1861         ebhdr = kmem_alloc(sizeof(struct chfs_eb_hdr), KM_SLEEP);
1862
1863         /* Setting up eraseblock header properties */
1864         ebh->ops->create_eb_hdr(ebhdr, lnr);
1865
1866 retry:
1867         /* Getting a physical eraseblock from the wear leveling system */
1868         pebnr = get_peb(ebh);
1869         if (pebnr < 0) {
1870                 leb_write_unlock(ebh, lnr);
1871                 kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
1872                 return pebnr;
1873         }
1874
1875         /* Write the eraseblock header to the media */
1876         err = ebh->ops->write_eb_hdr(ebh, pebnr, ebhdr);
1877         if (err) {
1878                 chfs_warn(
1879                         "error writing eraseblock header: LEB %d , PEB %d\n",
1880                         lnr, pebnr);
1881                 goto write_error;
1882         }
1883
1884         /* Write out data */
1885         if (len) {
1886                 data_offset = ebh->ops->calc_data_offs(ebh, pebnr, offset);
1887                 err = flash_write(ebh->flash_dev,
1888                     data_offset, len, retlen, (unsigned char *) buf);
1889                 if (err) {
1890                         chfs_err("error %d while writing %zu bytes to PEB "
1891                             " %d:%ju, written %zu bytes\n",
1892                             err, len, pebnr, (uintmax_t )offset, *retlen);
1893                         goto write_error;
1894                 }
1895         }
1896
1897         ebh->lmap[lnr] = pebnr;
1898         leb_write_unlock(ebh, lnr);
1899         kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
1900
1901         return 0;
1902
1903 write_error: err = release_peb(ebh, pebnr);
1904         // max retries (NOW: 2)
1905         if (err || CHFS_MAX_GET_PEB_RETRIES < ++retries) {
1906                 leb_write_unlock(ebh, lnr);
1907                 kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
1908                 return err;
1909         }
1910         goto retry;
1911 }
1912
1913 /**
1914  * ebh_erase_leb - erase a leb
1915  * @ebh: eraseblock handler
1916  * @lnr: leb number
1917  *
1918  * Returns zero in case of success, error code in case of fail.
1919  */
1920 int
1921 ebh_erase_leb(struct chfs_ebh *ebh, int lnr)
1922 {
1923         int err, pebnr;
1924
1925         leb_write_lock(ebh, lnr);
1926
1927         pebnr = ebh->lmap[lnr];
1928         if (pebnr < 0) {
1929                 leb_write_unlock(ebh, lnr);
1930                 return EBH_LEB_UNMAPPED;
1931         }
1932         err = release_peb(ebh, pebnr);
1933         if (err)
1934                 goto out_unlock;
1935
1936         ebh->lmap[lnr] = EBH_LEB_UNMAPPED;
1937         cv_signal(&ebh->bg_erase.eth_wakeup);
1938 out_unlock:
1939         leb_write_unlock(ebh, lnr);
1940         return err;
1941 }
1942
1943 /**
1944  * ebh_map_leb - maps a PEB to LEB
1945  * @ebh: eraseblock handler
1946  * @lnr: leb number
1947  *
1948  * Returns zero on success, error code in case of fail
1949  */
1950 int
1951 ebh_map_leb(struct chfs_ebh *ebh, int lnr)
1952 {
1953         int err, pebnr, retries = 0;
1954         struct chfs_eb_hdr *ebhdr;
1955
1956         ebhdr = kmem_alloc(sizeof(struct chfs_eb_hdr), KM_SLEEP);
1957
1958         err = leb_write_lock(ebh, lnr);
1959         if (err) {
1960                 kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
1961                 return err;
1962         }
1963
1964 retry:
1965         pebnr = get_peb(ebh);
1966         if (pebnr < 0) {
1967                 err = pebnr;
1968                 goto out_unlock;
1969         }
1970
1971         ebh->ops->create_eb_hdr(ebhdr, lnr);
1972
1973         err = ebh->ops->write_eb_hdr(ebh, pebnr, ebhdr);
1974         if (err) {
1975                 chfs_warn(
1976                         "error writing eraseblock header: LEB %d , PEB %d\n",
1977                         lnr, pebnr);
1978                 goto write_error;
1979         }
1980
1981         ebh->lmap[lnr] = pebnr;
1982
1983 out_unlock:
1984         leb_write_unlock(ebh, lnr);
1985         return err;
1986
1987 write_error:
1988         err = release_peb(ebh, pebnr);
1989         // max retries (NOW: 2)
1990         if (err || CHFS_MAX_GET_PEB_RETRIES < ++retries) {
1991                 leb_write_unlock(ebh, lnr);
1992                 kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
1993                 return err;
1994         }
1995         goto retry;
1996 }
1997
1998 /**
1999  * ebh_unmap_leb -
2000  * @ebh: eraseblock handler
2001  * @lnr: leb number
2002  *
2003  * Retruns zero on success, error code in case of fail.
2004  */
2005 int
2006 ebh_unmap_leb(struct chfs_ebh *ebh, int lnr)
2007 {
2008         int err;
2009
2010         if (ebh_is_mapped(ebh, lnr) < 0)
2011                 /* If the eraseblock already unmapped */
2012                 return 0;
2013
2014         err = ebh_erase_leb(ebh, lnr);
2015
2016         return err;
2017 }
2018
2019 /**
2020  * ebh_is_mapped - check if a PEB is mapped to @lnr
2021  * @ebh: eraseblock handler
2022  * @lnr: leb number
2023  *
2024  * Retruns 0 if the logical eraseblock is mapped, negative error code otherwise.
2025  */
2026 int
2027 ebh_is_mapped(struct chfs_ebh *ebh, int lnr)
2028 {
2029         int err, result;
2030         err = leb_read_lock(ebh, lnr);
2031         if (err)
2032                 return err;
2033
2034         result = ebh->lmap[lnr];
2035         leb_read_unlock(ebh, lnr);
2036
2037         return result;
2038 }
2039
2040 /**
2041  * ebh_change_leb - write the LEB to another PEB
2042  * @ebh: eraseblock handler
2043  * @lnr: leb number
2044  * @buf: data to write
2045  * @len: length of data
2046  * Returns zero in case of success, error code in case of fail.
2047  */
2048 int
2049 ebh_change_leb(struct chfs_ebh *ebh, int lnr, char *buf, size_t len,
2050     size_t *retlen)
2051 {
2052         int err, pebnr, pebnr_old, retries = 0;
2053         off_t data_offset;
2054
2055         struct chfs_peb *peb = NULL;
2056         struct chfs_eb_hdr *ebhdr;
2057
2058         if (ebh_is_mapped(ebh, lnr) < 0)
2059                 return EBH_LEB_UNMAPPED;
2060
2061         if (len == 0) {
2062                 err = ebh_unmap_leb(ebh, lnr);
2063                 if (err)
2064                         return err;
2065                 return ebh_map_leb(ebh, lnr);
2066         }
2067
2068         ebhdr = kmem_alloc(sizeof(struct chfs_eb_hdr), KM_SLEEP);
2069
2070         pebnr_old = ebh->lmap[lnr];
2071
2072         mutex_enter(&ebh->alc_mutex);
2073         err = leb_write_lock(ebh, lnr);
2074         if (err)
2075                 goto out_mutex;
2076
2077         if (ebh->ops->mark_eb_hdr_dirty_flash) {
2078                 err = ebh->ops->mark_eb_hdr_dirty_flash(ebh, pebnr_old, lnr);
2079                 if (err)
2080                         goto out_unlock;
2081         }
2082
2083         /* Setting up eraseblock header properties */
2084         ebh->ops->create_eb_hdr(ebhdr, lnr);
2085
2086 retry:
2087         /* Getting a physical eraseblock from the wear leveling system */
2088         pebnr = get_peb(ebh);
2089         if (pebnr < 0) {
2090                 leb_write_unlock(ebh, lnr);
2091                 mutex_exit(&ebh->alc_mutex);
2092                 kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
2093                 return pebnr;
2094         }
2095
2096         err = ebh->ops->write_eb_hdr(ebh, pebnr, ebhdr);
2097         if (err) {
2098                 chfs_warn(
2099                         "error writing eraseblock header: LEB %d , PEB %d",
2100                         lnr, pebnr);
2101                 goto write_error;
2102         }
2103
2104         /* Write out data */
2105         data_offset = ebh->ops->calc_data_offs(ebh, pebnr, 0);
2106         err = flash_write(ebh->flash_dev, data_offset, len, retlen,
2107             (unsigned char *) buf);
2108         if (err) {
2109                 chfs_err("error %d while writing %zu bytes to PEB %d:%ju,"
2110                     " written %zu bytes",
2111                     err, len, pebnr, (uintmax_t)data_offset, *retlen);
2112                 goto write_error;
2113         }
2114
2115         ebh->lmap[lnr] = pebnr;
2116
2117         if (ebh->ops->invalidate_eb_hdr) {
2118                 err = ebh->ops->invalidate_eb_hdr(ebh, pebnr_old);
2119                 if (err)
2120                         goto out_unlock;
2121         }
2122         peb = find_peb_in_use(ebh, pebnr_old);
2123         err = release_peb(ebh, peb->pebnr);
2124
2125 out_unlock:
2126         leb_write_unlock(ebh, lnr);
2127
2128 out_mutex:
2129         mutex_exit(&ebh->alc_mutex);
2130         kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
2131         kmem_free(peb, sizeof(struct chfs_peb));
2132         return err;
2133
2134 write_error:
2135         err = release_peb(ebh, pebnr);
2136         //max retries (NOW: 2)
2137         if (err || CHFS_MAX_GET_PEB_RETRIES < ++retries) {
2138                 leb_write_unlock(ebh, lnr);
2139                 mutex_exit(&ebh->alc_mutex);
2140                 kmem_free(ebhdr, sizeof(struct chfs_eb_hdr));
2141                 return err;
2142         }
2143         goto retry;
2144 }
2145