sys/ufs/chfs/chfs_scan.c

   1 /*      $NetBSD: chfs_scan.c,v 1.2 2011/11/24 21:09:37 agc 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  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to The NetBSD Foundation
  10  * by the Department of Software Engineering, University of Szeged, Hungary
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * chfs_scan.c
  36  *
  37  *  Created on: 2009.11.05.
  38  *      Author: dtengeri
  39  */
  40
  41 #include "chfs.h"
  42
  43 /**
  44  * chfs_scan_make_vnode_cache - makes a new vnode cache during scan
  45  * @chmp: CHFS main descriptor structure
  46  * @vno: vnode identifier
  47  * This function returns a vnode cache belonging to @vno.
  48  */
  49 struct chfs_vnode_cache *
  50 chfs_scan_make_vnode_cache(struct chfs_mount *chmp, ino_t vno)
  51 {
  52         struct chfs_vnode_cache *vc;
  53
  54         KASSERT(mutex_owned(&chmp->chm_lock_vnocache));
  55
  56         vc = chfs_vnode_cache_get(chmp, vno);
  57         if (vc) {
  58                 return vc;
  59         }
  60
  61         if (vno > chmp->chm_max_vno) {
  62                 chmp->chm_max_vno = vno;
  63         }
  64
  65         vc = chfs_vnode_cache_alloc(vno);
  66
  67         //mutex_enter(&chmp->chm_lock_vnocache);
  68
  69         chfs_vnode_cache_add(chmp, vc);
  70
  71         //mutex_exit(&chmp->chm_lock_vnocache);
  72
  73         if (vno == CHFS_ROOTINO) {
  74                 vc->nlink = 2;
  75                 vc->pvno = CHFS_ROOTINO;
  76                 chfs_vnode_cache_set_state(chmp,
  77                     vc, VNO_STATE_CHECKEDABSENT);
  78         }
  79
  80         return vc;
  81 }
  82
  83 /**
  84  * chfs_scan_check_node_hdr - checks node magic and crc
  85  * @nhdr: node header to check
  86  * Returns 0 if everything is OK, error code otherwise.
  87  */
  88 int
  89 chfs_scan_check_node_hdr(struct chfs_flash_node_hdr *nhdr)
  90 {
  91         uint16_t magic;
  92         uint32_t crc, hdr_crc;
  93
  94         magic = le16toh(nhdr->magic);
  95
  96         if (magic != CHFS_FS_MAGIC_BITMASK) {
  97                 dbg("bad magic\n");
  98                 return CHFS_NODE_BADMAGIC;
  99         }
 100
 101         hdr_crc = le32toh(nhdr->hdr_crc);
 102         crc = crc32(0, (uint8_t *)nhdr, CHFS_NODE_HDR_SIZE - 4);
 103
 104         if (crc != hdr_crc) {
 105                 dbg("bad crc\n");
 106                 return CHFS_NODE_BADCRC;
 107         }
 108
 109         return CHFS_NODE_OK;
 110 }
 111
 112 /**
 113  * chfs_scan_check_vnode - check vnode crc and add to vnode cache
 114  * @chmp: CHFS main descriptor structure
 115  * @cheb: eraseblock informations
 116  * @buf: vnode to check
 117  * @ofs: offset in eraseblock where vnode starts
 118  */
 119 int
 120 chfs_scan_check_vnode(struct chfs_mount *chmp,
 121     struct chfs_eraseblock *cheb, void *buf, off_t ofs)
 122 {
 123         KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
 124         struct chfs_vnode_cache *vc;
 125         struct chfs_flash_vnode *vnode = buf;
 126         struct chfs_node_ref *nref;
 127         int err;
 128         uint32_t crc;
 129         ino_t vno;
 130
 131         crc = crc32(0, (uint8_t *)vnode,
 132             sizeof(struct chfs_flash_vnode) - 4);
 133
 134         if (crc != le32toh(vnode->node_crc)) {
 135                 err = chfs_update_eb_dirty(chmp,
 136                     cheb, le32toh(vnode->length));
 137                 if (err) {
 138                         return err;
 139                 }
 140
 141                 return CHFS_NODE_BADCRC;
 142         }
 143
 144         vno = le64toh(vnode->vno);
 145
 146         mutex_enter(&chmp->chm_lock_vnocache);
 147         vc = chfs_vnode_cache_get(chmp, vno);
 148         if (!vc) {
 149                 vc = chfs_scan_make_vnode_cache(chmp, vno);
 150                 if (!vc) {
 151                         mutex_exit(&chmp->chm_lock_vnocache);
 152                         return ENOMEM;
 153                 }
 154         }
 155         mutex_exit(&chmp->chm_lock_vnocache);
 156
 157         nref = chfs_alloc_node_ref(cheb);
 158
 159         nref->nref_offset = ofs;
 160
 161         KASSERT(nref->nref_lnr == cheb->lnr);
 162
 163         /* Check version of vnode. */
 164         if ((struct chfs_vnode_cache *)vc->v != vc) {
 165                 if (le64toh(vnode->version) > *vc->vno_version) {
 166                         //err = chfs_update_eb_dirty(chmp, &chmp->chm_blocks[vc->v->lnr],
 167                         //              sizeof(struct chfs_flash_vnode));
 168                         *vc->vno_version = le64toh(vnode->version);
 169                         chfs_add_vnode_ref_to_vc(chmp, vc, nref);
 170                 } else {
 171                         err = chfs_update_eb_dirty(chmp, cheb,
 172                             sizeof(struct chfs_flash_vnode));
 173                         return CHFS_NODE_OK;
 174                 }
 175         } else {
 176                 vc->vno_version = kmem_alloc(sizeof(uint64_t), KM_SLEEP);
 177                 if (!vc->vno_version)
 178                         return ENOMEM;
 179                 *vc->vno_version = le64toh(vnode->version);
 180                 chfs_add_vnode_ref_to_vc(chmp, vc, nref);
 181         }
 182
 183         mutex_enter(&chmp->chm_lock_sizes);
 184         //dbg("B:lnr: %d |free_size: %d node's size: %d\n", cheb->lnr, cheb->free_size, le32toh(vnode->length));
 185         chfs_change_size_free(chmp, cheb, -le32toh(vnode->length));
 186         chfs_change_size_used(chmp, cheb, le32toh(vnode->length));
 187         mutex_exit(&chmp->chm_lock_sizes);
 188
 189         KASSERT(cheb->used_size <= chmp->chm_ebh->eb_size);
 190
 191         KASSERT(cheb->used_size + cheb->free_size + cheb->dirty_size + cheb->unchecked_size + cheb->wasted_size == chmp->chm_ebh->eb_size);
 192
 193         //dbg(" A: free_size: %d\n", cheb->free_size);
 194
 195         /*dbg("vnode dump:\n");
 196           dbg(" ->magic:    0x%x\n", le16toh(vnode->magic));
 197           dbg(" ->type:     %d\n", le16toh(vnode->type));
 198           dbg(" ->length:   %d\n", le32toh(vnode->length));
 199           dbg(" ->hdr_crc:  0x%x\n", le32toh(vnode->hdr_crc));
 200           dbg(" ->vno:      %d\n", le64toh(vnode->vno));
 201           dbg(" ->version:  %ld\n", le64toh(vnode->version));
 202           dbg(" ->uid:      %d\n", le16toh(vnode->uid));
 203           dbg(" ->gid:      %d\n", le16toh(vnode->gid));
 204           dbg(" ->mode:     %d\n", le32toh(vnode->mode));
 205           dbg(" ->dn_size:  %d\n", le32toh(vnode->dn_size));
 206           dbg(" ->atime:    %d\n", le32toh(vnode->atime));
 207           dbg(" ->mtime:    %d\n", le32toh(vnode->mtime));
 208           dbg(" ->ctime:    %d\n", le32toh(vnode->ctime));
 209           dbg(" ->dsize:    %d\n", le32toh(vnode->dsize));
 210           dbg(" ->node_crc: 0x%x\n", le32toh(vnode->node_crc));*/
 211
 212         return CHFS_NODE_OK;
 213 }
 214
 215 int
 216 chfs_scan_mark_dirent_obsolete(struct chfs_mount *chmp,
 217     struct chfs_vnode_cache *vc, struct chfs_dirent *fd)
 218 {
 219         //int size;
 220         struct chfs_eraseblock *cheb;
 221         struct chfs_node_ref *prev, *nref;
 222
 223         nref = fd->nref;
 224         cheb = &chmp->chm_blocks[fd->nref->nref_lnr];
 225
 226         /* Remove dirent's node ref from vnode cache */
 227         prev = vc->dirents;
 228         if (prev && prev == nref) {
 229                 vc->dirents = prev->nref_next;
 230         } else if (prev && prev != (void *)vc) {
 231                 while (prev->nref_next && prev->nref_next !=
 232                     (void *)vc && prev->nref_next != nref) {
 233                         prev = prev->nref_next;
 234                 }
 235
 236                 if (prev->nref_next == nref) {
 237                         prev->nref_next = nref->nref_next;
 238                 }
 239         }
 240         /*dbg("XXX - start\n");
 241         //nref = vc->dirents;
 242         struct chfs_dirent *tmp;
 243         tmp = vc->scan_dirents;
 244         while (tmp) {
 245         dbg(" ->tmp->name:    %s\n", tmp->name);
 246         dbg(" ->tmp->version: %ld\n", tmp->version);
 247         dbg(" ->tmp->vno: %d\n", tmp->vno);
 248         tmp = tmp->next;
 249         }
 250         dbg("XXX - end\n");*/
 251         //size = CHFS_PAD(sizeof(struct chfs_flash_dirent_node) + fd->nsize);
 252
 253         KASSERT(cheb->used_size + cheb->free_size + cheb->dirty_size +
 254             cheb->unchecked_size + cheb->wasted_size == chmp->chm_ebh->eb_size);
 255
 256         return 0;
 257 }
 258
 259 void
 260 chfs_add_fd_to_list(struct chfs_mount *chmp,
 261     struct chfs_dirent *new, struct chfs_vnode_cache *pvc)
 262 {
 263         KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
 264         int size;
 265         struct chfs_eraseblock *cheb, *oldcheb;
 266 //      struct chfs_dirent **prev;
 267         struct chfs_dirent *fd, *tmpfd;
 268
 269         dbg("adding fd to list: %s\n", new->name);
 270
 271         if ((new->version > pvc->highest_version))
 272                 pvc->highest_version = new->version;
 273
 274         size = CHFS_PAD(sizeof(struct chfs_flash_dirent_node) +
 275             new->nsize);
 276         cheb = &chmp->chm_blocks[new->nref->nref_lnr];
 277
 278         mutex_enter(&chmp->chm_lock_sizes);
 279         TAILQ_FOREACH_SAFE(fd, &pvc->scan_dirents, fds, tmpfd) {
 280                 if (fd->nhash > new->nhash) {
 281                         /* insert new before fd */
 282                         TAILQ_INSERT_BEFORE(fd, new, fds);
 283                         goto out;
 284                 } else if (fd->nhash == new->nhash &&
 285                     !strcmp(fd->name, new->name)) {
 286                         if (new->version > fd->version) {
 287 //                              new->next = fd->next;
 288                                 /* replace fd with new */
 289                                 TAILQ_INSERT_BEFORE(fd, new, fds);
 290                                 chfs_change_size_free(chmp, cheb, -size);
 291                                 chfs_change_size_used(chmp, cheb, size);
 292
 293                                 TAILQ_REMOVE(&pvc->scan_dirents, fd, fds);
 294                                 if (fd->nref) {
 295                                         size = CHFS_PAD(sizeof(struct chfs_flash_dirent_node) + fd->nsize);
 296                                         chfs_scan_mark_dirent_obsolete(chmp, pvc, fd);
 297                                         oldcheb = &chmp->chm_blocks[fd->nref->nref_lnr];
 298                                         chfs_change_size_used(chmp, oldcheb, -size);
 299                                         chfs_change_size_dirty(chmp, oldcheb, size);
 300                                 }
 301                                 chfs_free_dirent(fd);
 302 //                              *prev = new;//XXX
 303                         } else {
 304                                 chfs_scan_mark_dirent_obsolete(chmp, pvc, new);
 305                                 chfs_change_size_free(chmp, cheb, -size);
 306                                 chfs_change_size_dirty(chmp, cheb, size);
 307                                 chfs_free_dirent(new);
 308                         }
 309                         /*dbg("START\n");
 310                           fd = pvc->scan_dirents;
 311                           while (fd) {
 312                           dbg("dirent dump:\n");
 313                           dbg(" ->vno:     %d\n", fd->vno);
 314                           dbg(" ->version: %ld\n", fd->version);
 315                           dbg(" ->nhash:   0x%x\n", fd->nhash);
 316                           dbg(" ->nsize:   %d\n", fd->nsize);
 317                           dbg(" ->name:    %s\n", fd->name);
 318                           dbg(" ->type:    %d\n", fd->type);
 319                           fd = fd->next;
 320                           }
 321                           dbg("END\n");*/
 322                         mutex_exit(&chmp->chm_lock_sizes);
 323                         return;
 324                 }
 325         }
 326         /* if we couldnt fit it elsewhere, lets add to the end */
 327         TAILQ_INSERT_TAIL(&pvc->scan_dirents, new, fds);
 328
 329 out:
 330         //dbg("B:lnr: %d |free_size: %d size: %d\n", cheb->lnr, cheb->free_size, size);
 331         chfs_change_size_free(chmp, cheb, -size);
 332         chfs_change_size_used(chmp, cheb, size);
 333         mutex_exit(&chmp->chm_lock_sizes);
 334
 335         KASSERT(cheb->used_size <= chmp->chm_ebh->eb_size);
 336         //dbg(" A: free_size: %d\n", cheb->free_size);
 337
 338         KASSERT(cheb->used_size + cheb->free_size + cheb->dirty_size + cheb->unchecked_size + cheb->wasted_size == chmp->chm_ebh->eb_size);
 339
 340
 341 //      fd = pvc->scan_dirents;
 342         /*dbg("START\n");
 343           while (fd) {
 344           dbg("dirent dump:\n");
 345           dbg(" ->vno:     %d\n", fd->vno);
 346           dbg(" ->version: %ld\n", fd->version);
 347           dbg(" ->nhash:   0x%x\n", fd->nhash);
 348           dbg(" ->nsize:   %d\n", fd->nsize);
 349           dbg(" ->name:    %s\n", fd->name);
 350           dbg(" ->type:    %d\n", fd->type);
 351           fd = fd->next;
 352           }
 353           dbg("END\n");*/
 354 }
 355 /**
 356  * chfs_scan_check_dirent_node - check vnode crc and add to vnode cache
 357  * @chmp: CHFS main descriptor structure
 358  * @cheb: eraseblock informations
 359  * @buf: directory entry to check
 360  * @ofs: offset in eraseblock where dirent starts
 361  */
 362 int
 363 chfs_scan_check_dirent_node(struct chfs_mount *chmp,
 364     struct chfs_eraseblock *cheb, void *buf, off_t ofs)
 365 {
 366         int err, namelen;
 367         uint32_t crc;
 368         struct chfs_dirent *fd;
 369         struct chfs_vnode_cache *vc;
 370         struct chfs_flash_dirent_node *dirent = buf;
 371
 372         //struct chfs_node_ref *tmp;
 373
 374         crc = crc32(0, (uint8_t *)dirent, sizeof(*dirent) - 4);
 375         if (crc != le32toh(dirent->node_crc)) {
 376                 err = chfs_update_eb_dirty(chmp, cheb, le32toh(dirent->length));
 377                 if (err)
 378                         return err;
 379                 return CHFS_NODE_BADCRC;
 380         }
 381         namelen = dirent->nsize;
 382
 383         fd = chfs_alloc_dirent(namelen + 1);
 384         if (!fd)
 385                 return ENOMEM;
 386
 387         fd->nref = chfs_alloc_node_ref(cheb);
 388         if (!fd->nref)
 389                 return ENOMEM;
 390
 391         KASSERT(fd->nref->nref_lnr == cheb->lnr);
 392
 393         memcpy(&fd->name, dirent->name, namelen);
 394         fd->nsize = namelen;
 395         fd->name[namelen] = 0;
 396         crc = crc32(0, fd->name, dirent->nsize);
 397         if (crc != le32toh(dirent->name_crc)) {
 398                 chfs_err("Directory entry's name has bad crc: read: 0x%x, "
 399                     "calculated: 0x%x\n", le32toh(dirent->name_crc), crc);
 400                 chfs_free_dirent(fd);
 401                 err = chfs_update_eb_dirty(chmp, cheb, le32toh(dirent->length));
 402                 if (err)
 403                         return err;
 404                 return CHFS_NODE_BADNAMECRC;
 405         }
 406
 407         /* Check vnode_cache of parent node */
 408         mutex_enter(&chmp->chm_lock_vnocache);
 409         vc = chfs_scan_make_vnode_cache(chmp, le64toh(dirent->pvno));
 410         mutex_exit(&chmp->chm_lock_vnocache);
 411         if (!vc) {
 412                 chfs_free_dirent(fd);
 413                 return ENOMEM;
 414         }
 415
 416         fd->nref->nref_offset = ofs;
 417
 418         dbg("add dirent to #%llu\n", (unsigned long long)vc->vno);
 419         chfs_add_node_to_list(chmp, vc, fd->nref, &vc->dirents);
 420         /*tmp = vc->dirents;
 421           dbg("START|vno: %d dirents dump\n", vc->vno);
 422           while (tmp) {
 423           dbg(" ->nref->nref_lnr:    %d\n", tmp->lnr);
 424           dbg(" ->nref->nref_offset: %d\n", tmp->offset);
 425           tmp = tmp->next;
 426           }
 427           dbg("  END|vno: %d dirents dump\n", vc->vno);*/
 428
 429 //      fd->next = NULL;
 430         fd->vno = le64toh(dirent->vno);
 431         fd->version = le64toh(dirent->version);
 432         fd->nhash = hash32_buf(fd->name, namelen, HASH32_BUF_INIT);
 433         fd->type = dirent->dtype;
 434
 435         /*dbg("dirent dump:\n");
 436           dbg(" ->vno:     %d\n", fd->vno);
 437           dbg(" ->version: %ld\n", fd->version);
 438           dbg(" ->nhash:   0x%x\n", fd->nhash);
 439           dbg(" ->nsize:   %d\n", fd->nsize);
 440           dbg(" ->name:    %s\n", fd->name);
 441           dbg(" ->type:    %d\n", fd->type);*/
 442
 443         chfs_add_fd_to_list(chmp, fd, vc);
 444
 445         /*struct chfs_node_ref *tmp;
 446           tmp = vc->dirents;
 447           dbg("START|vno: %d dirents dump\n", vc->vno);
 448           while (tmp) {
 449           dbg(" ->nref->nref_lnr:    %d\n", tmp->lnr);
 450           dbg(" ->nref->nref_offset: %d\n", tmp->offset);
 451           tmp = tmp->next;
 452           }
 453           dbg("  END|vno: %d dirents dump\n", vc->vno);*/
 454
 455         /*dbg("dirent dump:\n");
 456           dbg(" ->magic:    0x%x\n", le16toh(dirent->magic));
 457           dbg(" ->type:     %d\n", le16toh(dirent->type));
 458           dbg(" ->length:   %d\n", le32toh(dirent->length));
 459           dbg(" ->hdr_crc:  0x%x\n", le32toh(dirent->hdr_crc));
 460           dbg(" ->vno:      %d\n", le64toh(dirent->vno));
 461           dbg(" ->pvno:     %d\n", le64toh(dirent->pvno));
 462           dbg(" ->version:  %ld\n", le64toh(dirent->version));
 463           dbg(" ->mctime:   %d\n", le32toh(dirent->mctime));
 464           dbg(" ->nsize:    %d\n", dirent->nsize);
 465           dbg(" ->dtype:    %d\n", dirent->dtype);
 466           dbg(" ->name_crc: 0x%x\n", le32toh(dirent->name_crc));
 467           dbg(" ->node_crc: 0x%x\n", le32toh(dirent->node_crc));
 468           dbg(" ->name:     %s\n", dirent->name);*/
 469
 470         return CHFS_NODE_OK;
 471 }
 472
 473 /**
 474  * chfs_scan_check_data_node - check vnode crc and add to vnode cache
 475  * @chmp: CHFS main descriptor structure
 476  * @cheb: eraseblock informations
 477  * @buf: data node to check
 478  * @ofs: offset in eraseblock where data node starts
 479  */
 480 int
 481 chfs_scan_check_data_node(struct chfs_mount *chmp,
 482     struct chfs_eraseblock *cheb, void *buf, off_t ofs)
 483 {
 484         KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
 485         int err;
 486         uint32_t crc, vno;
 487         struct chfs_node_ref *nref;
 488         struct chfs_vnode_cache *vc;
 489         struct chfs_flash_data_node *dnode = buf;
 490
 491         crc = crc32(0, (uint8_t *)dnode, sizeof(struct chfs_flash_data_node) - 4);
 492         if (crc != le32toh(dnode->node_crc)) {
 493                 err = chfs_update_eb_dirty(chmp, cheb, le32toh(dnode->length));
 494                 if (err)
 495                         return err;
 496                 return CHFS_NODE_BADCRC;
 497         }
 498         /**
 499          * Don't check data nodes crc and version here, it will be done in
 500          * the background GC thread.
 501          */
 502         nref = chfs_alloc_node_ref(cheb);
 503         if (!nref)
 504                 return ENOMEM;
 505
 506         nref->nref_offset = ofs | CHFS_UNCHECKED_NODE_MASK;
 507
 508         KASSERT(nref->nref_lnr == cheb->lnr);
 509
 510         vno = le64toh(dnode->vno);
 511         mutex_enter(&chmp->chm_lock_vnocache);
 512         vc = chfs_vnode_cache_get(chmp, vno);
 513         if (!vc) {
 514                 vc = chfs_scan_make_vnode_cache(chmp, vno);
 515                 if (!vc)
 516                         return ENOMEM;
 517         }
 518         mutex_exit(&chmp->chm_lock_vnocache);
 519         chfs_add_node_to_list(chmp, vc, nref, &vc->dnode);
 520
 521         dbg("chmpfree: %u, chebfree: %u, dnode: %u\n", chmp->chm_free_size, cheb->free_size, dnode->length);
 522
 523         mutex_enter(&chmp->chm_lock_sizes);
 524         chfs_change_size_free(chmp, cheb, -dnode->length);
 525         chfs_change_size_unchecked(chmp, cheb, dnode->length);
 526         mutex_exit(&chmp->chm_lock_sizes);
 527         return CHFS_NODE_OK;
 528 }
 529
 530 /**
 531  * chfs_scan_classify_cheb - determine eraseblock's state
 532  * @chmp: CHFS main descriptor structure
 533  * @cheb: eraseblock to classify
 534  */
 535 int
 536 chfs_scan_classify_cheb(struct chfs_mount *chmp,
 537     struct chfs_eraseblock *cheb)
 538 {
 539         if (cheb->free_size == chmp->chm_ebh->eb_size)
 540                 return CHFS_BLK_STATE_FREE;
 541         else if (cheb->dirty_size < MAX_DIRTY_TO_CLEAN)
 542                 return CHFS_BLK_STATE_CLEAN;
 543         else if (cheb->used_size || cheb->unchecked_size)
 544                 return CHFS_BLK_STATE_PARTDIRTY;
 545         else
 546                 return CHFS_BLK_STATE_ALLDIRTY;
 547 }
 548
 549
 550 /**
 551  * chfs_scan_eraseblock - scans an eraseblock and looking for nodes
 552  * @chmp: CHFS main descriptor structure
 553  * @cheb: eraseblock to scan
 554  *
 555  * This function scans a whole eraseblock, checks the nodes on it and add them
 556  * to the vnode cache.
 557  * Returns eraseblock state on success, error code if fails.
 558  */
 559 int
 560 chfs_scan_eraseblock(struct chfs_mount *chmp,
 561     struct chfs_eraseblock *cheb) {
 562
 563         int err;
 564         size_t len, retlen;
 565         off_t ofs = 0;
 566         int lnr = cheb->lnr;
 567         u_char *buf;
 568         struct chfs_flash_node_hdr *nhdr;
 569         int read_free = 0;
 570         struct chfs_node_ref *nref;
 571
 572
 573         dbg("scanning eraseblock content: %d free_size: %d\n", cheb->lnr, cheb->free_size);
 574         dbg("scanned physical block: %d\n", chmp->chm_ebh->lmap[lnr]);
 575         buf = kmem_alloc(CHFS_MAX_NODE_SIZE, KM_SLEEP);
 576
 577         while((ofs + CHFS_NODE_HDR_SIZE) < chmp->chm_ebh->eb_size) {
 578                 memset(buf, 0 , CHFS_MAX_NODE_SIZE);
 579                 err = chfs_read_leb(chmp,
 580                     lnr, buf, ofs, CHFS_NODE_HDR_SIZE, &retlen);
 581                 if (err) {
 582                         return err;
 583                 }
 584
 585                 if (retlen != CHFS_NODE_HDR_SIZE) {
 586                         chfs_err("Error reading node header: "
 587                             "read: %zu instead of: %zu\n",
 588                             CHFS_NODE_HDR_SIZE, retlen);
 589                         return EIO;
 590                 }
 591
 592                 /* first we check if the buffer we read is full with 0xff, if yes maybe
 593                  * the blocks remaining area is free. We increase read_free and if it
 594                  * reaches MAX_READ_FREE we stop reading the block*/
 595                 if (check_pattern(buf, 0xff, 0, CHFS_NODE_HDR_SIZE)) {
 596                         read_free += CHFS_NODE_HDR_SIZE;
 597                         if (read_free >= MAX_READ_FREE(chmp)) {
 598                                 dbg("rest of the block is free. Size: %d\n", cheb->free_size);
 599                                 return chfs_scan_classify_cheb(chmp, cheb);
 600                         }
 601                         ofs += CHFS_NODE_HDR_SIZE;
 602                         continue;
 603                 } else {
 604                         chfs_update_eb_dirty(chmp, cheb, read_free);
 605                         read_free = 0;
 606                 }
 607
 608                 nhdr = (struct chfs_flash_node_hdr *)buf;
 609
 610                 err = chfs_scan_check_node_hdr(nhdr);
 611                 if (err) {
 612                         dbg("node hdr error\n");
 613                         err = chfs_update_eb_dirty(chmp, cheb, 4);
 614                         if (err) {
 615                                 return err;
 616                         }
 617
 618                         ofs += 4;
 619                         continue;
 620                 }
 621                 ofs += CHFS_NODE_HDR_SIZE;
 622                 if (ofs > chmp->chm_ebh->eb_size) {
 623                         chfs_err("Second part of node is on the next eraseblock.\n");
 624                         return EIO;
 625                 }
 626                 switch (le16toh(nhdr->type)) {
 627                 case CHFS_NODETYPE_VNODE:
 628                         /* Read up the node */
 629                         //dbg("nodetype vnode\n");
 630                         len = le32toh(nhdr->length) - CHFS_NODE_HDR_SIZE;
 631                         err = chfs_read_leb(chmp,
 632                             lnr, buf + CHFS_NODE_HDR_SIZE,
 633                             ofs, len,  &retlen);
 634                         if (err) {
 635                                 return err;
 636                         }
 637
 638                         if (retlen != len) {
 639                                 chfs_err("Error reading vnode: read: %zu instead of: %zu\n",
 640                                     len, retlen);
 641                                 return EIO;
 642                         }
 643                         KASSERT(lnr == cheb->lnr);
 644                         err = chfs_scan_check_vnode(chmp,
 645                             cheb, buf, ofs - CHFS_NODE_HDR_SIZE);
 646                         if (err) {
 647                                 return err;
 648                         }
 649
 650                         //dbg("XXX5end\n");
 651                         break;
 652                 case CHFS_NODETYPE_DIRENT:
 653                         /* Read up the node */
 654                         //dbg("nodetype dirent\n");
 655                         len = le32toh(nhdr->length) - CHFS_NODE_HDR_SIZE;
 656
 657                         err = chfs_read_leb(chmp,
 658                             lnr, buf + CHFS_NODE_HDR_SIZE,
 659                             ofs, len, &retlen);
 660                         if (err) {
 661                                 return err;
 662                         }
 663
 664                         if (retlen != len) {
 665                                 chfs_err("Error reading dirent node: read: %zu "
 666                                     "instead of: %zu\n", len, retlen);
 667                                 return EIO;
 668                         }
 669
 670                         KASSERT(lnr == cheb->lnr);
 671
 672                         err = chfs_scan_check_dirent_node(chmp,
 673                             cheb, buf, ofs - CHFS_NODE_HDR_SIZE);
 674                         if (err) {
 675                                 return err;
 676                         }
 677
 678                         //dbg("XXX6end\n");
 679                         break;
 680                 case CHFS_NODETYPE_DATA:
 681                         //dbg("nodetype data\n");
 682                         len = sizeof(struct chfs_flash_data_node) -
 683                             CHFS_NODE_HDR_SIZE;
 684                         err = chfs_read_leb(chmp,
 685                             lnr, buf + CHFS_NODE_HDR_SIZE,
 686                             ofs, len, &retlen);
 687                         if (err) {
 688                                 return err;
 689                         }
 690
 691                         if (retlen != len) {
 692                                 chfs_err("Error reading data node: read: %zu "
 693                                     "instead of: %zu\n", len, retlen);
 694                                 return EIO;
 695                         }
 696                         KASSERT(lnr == cheb->lnr);
 697                         err = chfs_scan_check_data_node(chmp,
 698                             cheb, buf, ofs - CHFS_NODE_HDR_SIZE);
 699                         if (err)
 700                                 return err;
 701
 702                         //dbg("XXX7end\n");
 703                         break;
 704                 case CHFS_NODETYPE_PADDING:
 705                         //dbg("nodetype padding\n");
 706                         //dbg("padding len: %d\n", le32toh(nhdr->length));
 707                         //dbg("BEF: cheb->free_size: %d\n", cheb->free_size);
 708                         nref = chfs_alloc_node_ref(cheb);
 709                         nref->nref_offset = ofs - CHFS_NODE_HDR_SIZE;
 710                         nref->nref_offset = CHFS_GET_OFS(nref->nref_offset) |
 711                             CHFS_OBSOLETE_NODE_MASK;
 712
 713                         err = chfs_update_eb_dirty(chmp, cheb,
 714                             le32toh(nhdr->length));
 715                         //dbg("AFT: cheb->free_size: %d\n", cheb->free_size);
 716                         if (err)
 717                                 return err;
 718
 719                         //dbg("XXX8end\n");
 720                         break;
 721                 default:
 722                         //dbg("nodetype ? (default)\n");
 723                         /* Unknown node type, update dirty and skip */
 724                         err = chfs_update_eb_dirty(chmp, cheb,
 725                             le32toh(nhdr->length));
 726                         if (err)
 727                                 return err;
 728
 729                         //dbg("XXX9end\n");
 730                         break;
 731                 }
 732                 ofs += le32toh(nhdr->length) - CHFS_NODE_HDR_SIZE;
 733         }
 734
 735         KASSERT(cheb->used_size + cheb->free_size + cheb->dirty_size +
 736             cheb->unchecked_size + cheb->wasted_size == chmp->chm_ebh->eb_size);
 737
 738         //dbg("XXX10\n");
 739         return chfs_scan_classify_cheb(chmp, cheb);
 740 }