sys/ufs/chfs/chfs.h

   1 /*      $NetBSD: chfs.h,v 1.4 2011/11/28 12:50:07 ahoka 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 #ifndef __CHFS_H__
  39 #define __CHFS_H__
  40
  41 #if 0
  42 #define DBG_MSG
  43 #define DBG_MSG_GC
  44 #endif
  45
  46 #include <sys/param.h>
  47 #include <sys/kernel.h>
  48 #include <sys/cdefs.h>
  49 #include <sys/stdint.h>
  50 #include <sys/types.h>
  51 #include <sys/tree.h>
  52 #include <sys/queue.h>
  53 #include <sys/kmem.h>
  54 #include <sys/endian.h>
  55 #include <sys/rwlock.h>
  56 #include <sys/condvar.h>
  57 #include <sys/mutex.h>
  58 #include <sys/kthread.h>
  59 #include <sys/rbtree.h>
  60 #include <sys/vnode.h>
  61 #include <sys/mount.h>
  62 #include <sys/hash.h>
  63 #include <sys/module.h>
  64 #include <sys/dirent.h>
  65
  66 #include <ufs/ufs/quota.h>
  67 #include <ufs/ufs/ufsmount.h>
  68 #include <ufs/ufs/dir.h>
  69
  70 /* XXX shouldnt be defined here, but needed by chfs_inode.h */
  71 TAILQ_HEAD(chfs_dirent_list, chfs_dirent);
  72
  73 #include "chfs_pool.h"
  74 #include "ebh.h"
  75 #include "media.h"
  76 #include "chfs_inode.h"
  77
  78 #ifndef MOUNT_CHFS
  79 #define MOUNT_CHFS "chfs"
  80 #endif
  81
  82 #define CHFS_ROOTINO ROOTINO    /* ROOTINO == 2 */
  83
  84 enum {
  85         VNO_STATE_UNCHECKED,    /* CRC checks not yet done */
  86         VNO_STATE_CHECKING,     /* CRC checks in progress */
  87         VNO_STATE_PRESENT,      /* In core */
  88         VNO_STATE_CHECKEDABSENT,/* Checked, cleared again */
  89         VNO_STATE_GC,           /* GCing a 'pristine' node */
  90         VNO_STATE_READING,      /* In read_inode() */
  91         VNO_STATE_CLEARING      /* In clear_inode() */
  92 };
  93
  94 #define VNODECACHE_SIZE 128
  95
  96 #define MAX_READ_FREE(chmp) (((chmp)->chm_ebh)->eb_size / 8)
  97 /* an eraseblock will be clean if its dirty size is smaller than this */
  98 #define MAX_DIRTY_TO_CLEAN 255
  99 #define VERY_DIRTY(chmp, size) ((size) >= (((chmp)->chm_ebh)->eb_size / 2))
 100
 101 #define CHFS_PAD(x) (((x)+3)&~3)
 102
 103 enum {
 104         CHFS_NODE_OK = 0,
 105         CHFS_NODE_BADMAGIC,
 106         CHFS_NODE_BADCRC,
 107         CHFS_NODE_BADNAMECRC
 108 };
 109
 110 enum {
 111         CHFS_BLK_STATE_FREE = 100,
 112         CHFS_BLK_STATE_CLEAN,
 113         CHFS_BLK_STATE_PARTDIRTY,
 114         CHFS_BLK_STATE_ALLDIRTY
 115 };
 116
 117 extern struct pool chfs_inode_pool;
 118 extern const struct genfs_ops chfs_genfsops;
 119
 120 /**
 121  * struct chfs_node_ref - a reference to a node
 122  * @lnr: logical identifier of the eraseblock where the node is
 123  * @offset: offset int hte eraseblock where the node starts
 124  * @next: used at data and dirent nodes, it points to the next data node which
 125  *                belongs to the same vnode
 126  */
 127 struct chfs_node_ref
 128 {
 129         struct chfs_node_ref *nref_next;
 130         uint32_t nref_lnr;
 131         uint32_t nref_offset;
 132 };
 133
 134 /* Constants  for allocating node refs */
 135 #define REFS_BLOCK_LEN (255/sizeof(struct chfs_node_ref))
 136 #define REF_EMPTY_NODE (UINT_MAX)
 137 #define REF_LINK_TO_NEXT (UINT_MAX - 1)
 138
 139 enum {
 140         CHFS_NORMAL_NODE_MASK,
 141         CHFS_UNCHECKED_NODE_MASK,
 142         CHFS_OBSOLETE_NODE_MASK,
 143         CHFS_PRISTINE_NODE_MASK
 144 };
 145
 146 #define CHFS_REF_FLAGS(ref)             ((ref)->nref_offset & 3)
 147 #define CHFS_REF_OBSOLETE(ref)  (((ref)->nref_offset & 3) == CHFS_OBSOLETE_NODE_MASK)
 148 #define CHFS_MARK_REF_NORMAL(ref)                                             \
 149         do {                                                                  \
 150                 (ref)->nref_offset = CHFS_GET_OFS((ref)->nref_offset) | CHFS_NORMAL_NODE_MASK; \
 151         } while(0)
 152
 153 #define CHFS_GET_OFS(ofs) (ofs & ~ 3)
 154
 155 static inline struct chfs_node_ref *
 156 node_next(struct chfs_node_ref *nref)
 157 {
 158         //dbg("node next: %u : %u\n", nref->nref_lnr, nref->nref_offset);
 159         nref++;
 160         //dbg("nref++: %u : %u\n", nref->nref_lnr, nref->nref_offset);
 161
 162         if (nref->nref_lnr == REF_LINK_TO_NEXT) {
 163                 //dbg("link to next\n");
 164                 nref = nref->nref_next;
 165                 if (!nref)
 166                         return nref;
 167         }
 168
 169         if (nref->nref_lnr == REF_EMPTY_NODE) {
 170                 //dbg("empty\n");
 171                 return NULL;
 172         }
 173
 174         return nref;
 175 }
 176
 177 /**
 178  * struct chfs_dirent - full representation of a directory entry
 179  */
 180 struct chfs_dirent
 181 {
 182         struct chfs_node_ref *nref;
 183 //      struct chfs_dirent *next;
 184         TAILQ_ENTRY(chfs_dirent) fds;
 185         uint64_t version;
 186         ino_t vno;
 187         uint32_t nhash;
 188         enum vtype type;
 189         uint8_t  nsize;
 190         uint8_t  name[0];
 191
 192         /* used by chfs_alloc_dirent and free counterpart */
 193 //      size_t alloc_size;
 194 };
 195
 196 struct chfs_tmp_dnode {
 197         struct chfs_full_dnode *node;
 198         uint64_t version;
 199         uint32_t data_crc;
 200         //uint32_t partial_crc;
 201         //uint16_t csize;
 202         uint16_t overlapped;
 203         struct chfs_tmp_dnode *next;
 204 };
 205
 206 struct chfs_tmp_dnode_info {
 207         struct rb_node rb_node;
 208         struct chfs_tmp_dnode *tmpnode;
 209 };
 210
 211 struct chfs_readinode_info {
 212         struct rb_tree tdi_root;
 213         struct chfs_tmp_dnode_info *mdata_tn;
 214         uint64_t highest_version;
 215         struct chfs_node_ref *latest_ref;
 216 };
 217
 218 struct chfs_full_dnode {
 219         struct chfs_node_ref *nref;
 220         uint64_t ofs;
 221         uint32_t size;
 222         uint32_t frags;
 223 };
 224
 225 struct chfs_node_frag {
 226         struct rb_node rb_node;
 227         struct chfs_full_dnode *node;
 228         uint32_t size;
 229         uint64_t ofs;
 230 };
 231
 232 static inline struct chfs_node_frag *
 233 frag_first(struct rb_tree *tree)
 234 {
 235         struct chfs_node_frag *frag;
 236
 237         frag = (struct chfs_node_frag *)RB_TREE_MIN(tree);
 238
 239         return frag;
 240 }
 241
 242 static inline struct chfs_node_frag *
 243 frag_last(struct rb_tree *tree)
 244 {
 245         struct chfs_node_frag *frag;
 246
 247         frag = (struct chfs_node_frag *)RB_TREE_MAX(tree);
 248
 249         return frag;
 250 }
 251
 252 #define frag_next(tree, frag) (struct chfs_node_frag *)rb_tree_iterate(tree, frag, RB_DIR_RIGHT)
 253 #define frag_prev(tree, frag) (struct chfs_node_frag *)rb_tree_iterate(tree, frag, RB_DIR_LEFT)
 254
 255
 256 /* XXX hack
 257    #ifndef CHFS_FRAG_TREE
 258    #define CHFS_FRAG_TREE
 259    RB_HEAD(chfs_frag_tree, chfs_node_frag);
 260    #endif
 261 */
 262
 263 /* for prototypes, properly defined in chfs_inode.h */
 264 //struct chfs_inode_ext;
 265
 266 /**
 267  * struct chfs_vnode_cache - in memory representation of a vnode
 268  * @v: pointer to the vnode info node
 269  * @dnode: pointer to the list of data nodes
 270  * @dirents: pointer to the list of directory entries
 271  * @vno_version: used only during scan, holds the current version number of
 272  *                               chfs_flash_vnode
 273  * @scan_dirents: used only during scan, holds the full representation of
 274  *                                directory entries of this vnode
 275  * @pvno: parent vnode number
 276  * @nlink: number of links to this vnode
 277  */
 278 struct chfs_vnode_cache {
 279 //      struct chfs_dirent *scan_dirents;
 280         void *p;
 281         struct chfs_dirent_list scan_dirents;
 282
 283         struct chfs_node_ref *v;
 284         struct chfs_node_ref *dnode;
 285         struct chfs_node_ref *dirents;
 286
 287         uint64_t *vno_version;
 288         uint64_t highest_version;
 289
 290         uint8_t flags;
 291         uint16_t state;
 292         ino_t vno;
 293         ino_t pvno;
 294         struct chfs_vnode_cache* next;
 295         uint32_t nlink;
 296 };
 297
 298 struct chfs_eraseblock
 299 {
 300         uint32_t lnr;
 301
 302         TAILQ_ENTRY(chfs_eraseblock) queue;
 303         //uint32_t bad_count;
 304         uint32_t unchecked_size;
 305         uint32_t used_size;
 306         uint32_t dirty_size;
 307         uint32_t free_size;
 308         uint32_t wasted_size;
 309
 310         struct chfs_node_ref *first_node;
 311         struct chfs_node_ref *last_node;
 312
 313         /* Next block to be garbage collected */
 314         struct chfs_node_ref *gc_node;
 315 };
 316
 317 TAILQ_HEAD(chfs_eraseblock_queue, chfs_eraseblock);
 318
 319 #define ALLOC_NORMAL    0
 320 #define ALLOC_DELETION  1
 321 #define ALLOC_GC        2
 322
 323 struct garbage_collector_thread {
 324         lwp_t *gcth_thread;
 325         kcondvar_t gcth_wakeup;
 326         bool gcth_running;
 327 };
 328
 329 #define CHFS_MP_FLAG_SCANNING 2
 330 #define CHFS_MP_FLAG_BUILDING 4
 331
 332 /**
 333  * struct chfs_mount - CHFS main descriptor structure
 334  * @ebh: eraseblock handler
 335  * @fl_index: index of flash device in the flash layer
 336  * @fs_version: filesystem version descriptor
 337  * @gbl_version: global version number
 338  * @max_vno: max vnode id
 339  * @chm_lock_mountfields:
 340  * @vnocache_hash: hash table of vnode caches
 341  * @vnocache_lock:
 342  * @blocks: array of eraseblocks on flash
 343  * @chm_root: used to protect all fields
 344  * @free_size: free size on the flash
 345  * @dirty_size: dirtied size on flash
 346  * @unchecked_size: size of unchecked data on flash
 347  * @free_queue: queue of free eraseblocks
 348  * @clean_queue: queue of clean eraseblocks
 349  * @dirty_queue: queue of dirty eraseblocks
 350  * @very_dirty_queue: queue of very dirty eraseblocks
 351  * @erase_pending_queue: queue of eraseblocks waiting for erasing
 352  * @erasable_pending_wbuf_queue: queue of eraseblocks waiting for erasing and
 353  *                               have data to write to them
 354  * @nextblock: next eraseblock to write to
 355  * @nr_free_blocks: number of free blocks on the free_queue
 356  * @nr_erasable_blocks: number of blocks that can be erased and are on the
 357  *                      erasable_queue
 358  */
 359 struct chfs_mount {
 360         struct mount *chm_fsmp;
 361         struct chfs_ebh *chm_ebh;
 362         int chm_fs_version;
 363         uint64_t chm_gbl_version;
 364         ino_t chm_max_vno;
 365         ino_t chm_checked_vno;
 366         unsigned int chm_flags;
 367
 368         /* chm_lock_mountfields:
 369          * Used to protect all the following fields. */
 370         kmutex_t chm_lock_mountfields;
 371
 372         struct chfs_vnode_cache **chm_vnocache_hash;
 373         /* chm_lock_vnocache:
 374          * Used to protect the vnode cache.
 375          * If you have to lock chm_lock_mountfields and also chm_lock_vnocache,
 376          * you must lock chm_lock_mountfields first. */
 377         kmutex_t chm_lock_vnocache;
 378
 379         struct chfs_eraseblock *chm_blocks;
 380
 381         struct chfs_node *chm_root;
 382
 383         uint32_t chm_free_size;
 384         uint32_t chm_dirty_size;
 385         uint32_t chm_unchecked_size;
 386         uint32_t chm_used_size;
 387         uint32_t chm_wasted_size;
 388         /* chm_lock_sizes:
 389          * Used to protect the (free, used, etc.) sizes of the FS
 390          * (and also the sizes of each eraseblock).
 391          * If you have to lock chm_lock_mountfields and also chm_lock_sizes,
 392          * you must lock chm_lock_mountfields first. */
 393         kmutex_t chm_lock_sizes;
 394
 395         struct chfs_eraseblock_queue chm_free_queue;
 396         struct chfs_eraseblock_queue chm_clean_queue;
 397         struct chfs_eraseblock_queue chm_dirty_queue;
 398         struct chfs_eraseblock_queue chm_very_dirty_queue;
 399         struct chfs_eraseblock_queue chm_erasable_pending_wbuf_queue;
 400         struct chfs_eraseblock_queue chm_erase_pending_queue;
 401
 402         uint8_t chm_resv_blocks_deletion;
 403         uint8_t chm_resv_blocks_write;
 404         uint8_t chm_resv_blocks_gctrigger;
 405         uint8_t chm_resv_blocks_gcmerge;
 406         uint8_t chm_nospc_dirty;
 407
 408         uint8_t chm_vdirty_blocks_gctrigger;
 409
 410         struct chfs_eraseblock *chm_nextblock;
 411
 412         struct garbage_collector_thread chm_gc_thread;
 413         struct chfs_eraseblock *chm_gcblock;
 414
 415         int chm_nr_free_blocks;
 416         int chm_nr_erasable_blocks;
 417
 418         int32_t chm_fs_bmask;
 419         int32_t chm_fs_bsize;
 420         int32_t chm_fs_qbmask;
 421         int32_t chm_fs_bshift;
 422         int32_t chm_fs_fmask;
 423         int64_t chm_fs_qfmask;
 424
 425         /* TODO will we use these? */
 426         unsigned int            chm_pages_max;
 427         unsigned int            chm_pages_used;
 428         unsigned int            chm_nodes_max;
 429         unsigned int            chm_nodes_cnt;
 430         struct chfs_pool        chm_dirent_pool;
 431         struct chfs_pool        chm_node_pool;
 432         struct chfs_str_pool    chm_str_pool;
 433         /**/
 434
 435         size_t chm_wbuf_pagesize;
 436         unsigned char* chm_wbuf;
 437         size_t chm_wbuf_ofs;
 438         size_t chm_wbuf_len;
 439         /* chm_lock_wbuf:
 440          * Used to protect the write buffer.
 441          * If you have to lock chm_lock_mountfields and also chm_lock_wbuf,
 442          * you must lock chm_lock_mountfields first. */
 443         krwlock_t chm_lock_wbuf;
 444 };
 445
 446 /*
 447  * TODO we should move here all of these from the bottom of the file
 448  * Macros/functions to convert from generic data structures to chfs
 449  * specific ones.
 450  */
 451
 452 #define CHFS_OFFSET_DOT         0
 453 #define CHFS_OFFSET_DOTDOT      1
 454 #define CHFS_OFFSET_EOF         2
 455 #define CHFS_OFFSET_FIRST       3
 456
 457
 458 /*---------------------------------------------------------------------------*/
 459
 460 /* chfs_build.c */
 461 void chfs_calc_trigger_levels(struct chfs_mount *);
 462 int chfs_build_filesystem(struct chfs_mount *);
 463 void chfs_build_set_vnodecache_nlink(struct chfs_mount *,
 464     struct chfs_vnode_cache *);
 465 void chfs_build_remove_unlinked_vnode(struct chfs_mount *,
 466     struct chfs_vnode_cache *, struct chfs_dirent_list *);
 467
 468 /* chfs_scan.c */
 469 int chfs_scan_eraseblock(struct chfs_mount *, struct chfs_eraseblock *);
 470 struct chfs_vnode_cache *chfs_scan_make_vnode_cache(struct chfs_mount *,
 471     ino_t);
 472 int chfs_scan_check_node_hdr(struct chfs_flash_node_hdr *);
 473 int chfs_scan_check_vnode(struct chfs_mount *,
 474     struct chfs_eraseblock *, void *, off_t);
 475 int chfs_scan_mark_dirent_obsolete(struct chfs_mount *,
 476     struct chfs_vnode_cache *, struct chfs_dirent *);
 477 void chfs_add_fd_to_list(struct chfs_mount *,
 478     struct chfs_dirent *, struct chfs_vnode_cache *);
 479 int chfs_scan_check_dirent_node(struct chfs_mount *,
 480     struct chfs_eraseblock *, void *, off_t);
 481 int chfs_scan_check_data_node(struct chfs_mount *,
 482     struct chfs_eraseblock *, void *, off_t);
 483 int chfs_scan_classify_cheb(struct chfs_mount *,
 484     struct chfs_eraseblock *);
 485
 486 /* chfs_nodeops.c */
 487 int chfs_update_eb_dirty(struct chfs_mount *,
 488     struct chfs_eraseblock *, uint32_t);
 489 void chfs_add_node_to_list(struct chfs_mount *, struct chfs_vnode_cache *,
 490     struct chfs_node_ref *, struct chfs_node_ref **);
 491 void chfs_add_fd_to_inode(struct chfs_mount *,
 492     struct chfs_inode *, struct chfs_dirent *);
 493 void chfs_add_vnode_ref_to_vc(struct chfs_mount *, struct chfs_vnode_cache *,
 494     struct chfs_node_ref *);
 495 struct chfs_node_ref* chfs_nref_next(struct chfs_node_ref *);
 496 int chfs_nref_len(struct chfs_mount *,
 497     struct chfs_eraseblock *, struct chfs_node_ref *);
 498 int chfs_close_eraseblock(struct chfs_mount *,
 499     struct chfs_eraseblock *);
 500 int chfs_reserve_space_normal(struct chfs_mount *, uint32_t, int);
 501 int chfs_reserve_space_gc(struct chfs_mount *, uint32_t);
 502 int chfs_reserve_space(struct chfs_mount *, uint32_t);
 503 void chfs_mark_node_obsolete(struct chfs_mount *, struct chfs_node_ref *);
 504
 505 static inline struct chfs_vnode_cache *
 506 chfs_nref_to_vc(struct chfs_node_ref *nref)
 507 {
 508         while (nref->nref_next) {
 509                 nref = nref->nref_next;
 510                 //dbg("lnr: %u, ofs: %u\n", nref->nref_lnr, nref->nref_offset);
 511                 //dbg("vno: %llu\n", ((struct chfs_vnode_cache *)(nref))->vno);
 512                 //dbg("scan_dirents: %p\n", ((struct chfs_vnode_cache *)(nref))->scan_dirents);
 513                 if (nref->nref_lnr == REF_LINK_TO_NEXT) {
 514                         dbg("Link to next!\n");
 515                 } else if (nref->nref_lnr == REF_EMPTY_NODE) {
 516                         dbg("Empty!\n");
 517                 }
 518         }
 519         //dbg("vno: %llu\n", ((struct chfs_vnode_cache *)(nref))->vno);
 520
 521         //dbg("NREF_TO_VC: GET IT\n");
 522         //dbg("nref_next: %p, lnr: %u, ofs: %u\n", nref->nref_next, nref->nref_lnr, nref->nref_offset);
 523         struct chfs_vnode_cache *vc = (struct chfs_vnode_cache *) nref;
 524         dbg("vno: %ju, pvno: %ju, hv: %ju, nlink: %u\n", (intmax_t )vc->vno,
 525             (intmax_t )vc->pvno, (intmax_t )vc->highest_version, vc->nlink);
 526         //return ((struct chfs_vnode_cache *)nref);
 527         return vc;
 528 }
 529
 530
 531 /* chfs_malloc.c */
 532 int chfs_alloc_pool_caches(void);
 533 void chfs_destroy_pool_caches(void);
 534 struct chfs_vnode_cache* chfs_vnode_cache_alloc(ino_t);
 535 void chfs_vnode_cache_free(struct chfs_vnode_cache *);
 536 struct chfs_node_ref* chfs_alloc_node_ref(
 537         struct chfs_eraseblock *);
 538 void chfs_free_node_refs(struct chfs_eraseblock *);
 539 struct chfs_dirent* chfs_alloc_dirent(int);
 540 void chfs_free_dirent(struct chfs_dirent *);
 541 struct chfs_flash_vnode* chfs_alloc_flash_vnode(void);
 542 void chfs_free_flash_vnode(struct chfs_flash_vnode *);
 543 struct chfs_flash_dirent_node* chfs_alloc_flash_dirent(void);
 544 void chfs_free_flash_dirent(struct chfs_flash_dirent_node *);
 545 struct chfs_flash_data_node* chfs_alloc_flash_dnode(void);
 546 void chfs_free_flash_dnode(struct chfs_flash_data_node *);
 547 struct chfs_node_frag* chfs_alloc_node_frag(void);
 548 void chfs_free_node_frag(struct chfs_node_frag *);
 549 struct chfs_node_ref* chfs_alloc_refblock(void);
 550 void chfs_free_refblock(struct chfs_node_ref *);
 551 struct chfs_full_dnode* chfs_alloc_full_dnode(void);
 552 void chfs_free_full_dnode(struct chfs_full_dnode *);
 553 struct chfs_tmp_dnode * chfs_alloc_tmp_dnode(void);
 554 void chfs_free_tmp_dnode(struct chfs_tmp_dnode *);
 555 struct chfs_tmp_dnode_info * chfs_alloc_tmp_dnode_info(void);
 556 void chfs_free_tmp_dnode_info(struct chfs_tmp_dnode_info *);
 557
 558 /* chfs_readinode.c */
 559 int chfs_read_inode(struct chfs_mount *, struct chfs_inode *);
 560 int chfs_read_inode_internal(struct chfs_mount *, struct chfs_inode *);
 561 void chfs_kill_fragtree(struct rb_tree *);
 562 uint32_t chfs_truncate_fragtree(struct chfs_mount *,
 563         struct rb_tree *, uint32_t);
 564 int chfs_add_full_dnode_to_inode(struct chfs_mount *,
 565     struct chfs_inode *,
 566     struct chfs_full_dnode *);
 567 int chfs_read_data(struct chfs_mount*, struct vnode *,
 568     struct buf *);
 569
 570 /* chfs_erase.c */
 571 int chfs_remap_leb(struct chfs_mount *);
 572
 573 /* chfs_ihash.c */
 574 void chfs_ihashinit(void);
 575 void chfs_ihashreinit(void);
 576 void chfs_ihashdone(void);
 577 struct vnode *chfs_ihashlookup(dev_t, ino_t);
 578 struct vnode *chfs_ihashget(dev_t, ino_t, int);
 579 void chfs_ihashins(struct chfs_inode *);
 580 void chfs_ihashrem(struct chfs_inode *);
 581
 582 extern kmutex_t chfs_ihash_lock;
 583 extern kmutex_t chfs_hashlock;
 584
 585 /* chfs_gc.c */
 586 void chfs_gc_trigger(struct chfs_mount *);
 587 int chfs_gc_thread_should_wake(struct chfs_mount *);
 588 void chfs_gc_thread(void *);
 589 void chfs_gc_thread_start(struct chfs_mount *);
 590 void chfs_gc_thread_stop(struct chfs_mount *);
 591 int chfs_gcollect_pass(struct chfs_mount *);
 592
 593 /* chfs_vfsops.c*/
 594 int chfs_gop_alloc(struct vnode *, off_t, off_t,  int, kauth_cred_t);
 595 int chfs_mountfs(struct vnode *, struct mount *);
 596
 597 /* chfs_vnops.c */
 598 extern int (**chfs_vnodeop_p)(void *);
 599 extern int (**chfs_specop_p)(void *);
 600 extern int (**chfs_fifoop_p)(void *);
 601 int chfs_lookup(void *);
 602 int chfs_create(void *);
 603 int chfs_mknod(void *);
 604 int chfs_open(void *);
 605 int chfs_close(void *);
 606 int chfs_access(void *);
 607 int chfs_getattr(void *);
 608 int chfs_setattr(void *);
 609 int chfs_chown(struct vnode *, uid_t, gid_t, kauth_cred_t);
 610 int chfs_chmod(struct vnode *, int, kauth_cred_t);
 611 int chfs_read(void *);
 612 int chfs_write(void *);
 613 int chfs_fsync(void *);
 614 int chfs_remove(void *);
 615 int chfs_link(void *);
 616 int chfs_rename(void *);
 617 int chfs_mkdir(void *);
 618 int chfs_rmdir(void *);
 619 int chfs_symlink(void *);
 620 int chfs_readdir(void *);
 621 int chfs_readlink(void *);
 622 int chfs_inactive(void *);
 623 int chfs_reclaim(void *);
 624 int chfs_advlock(void *);
 625 int chfs_strategy(void *);
 626 int chfs_bmap(void *);
 627
 628 /* chfs_vnode.c */
 629 struct vnode *chfs_vnode_lookup(struct chfs_mount *, ino_t);
 630 int chfs_readvnode(struct mount *, ino_t, struct vnode **);
 631 int chfs_readdirent(struct mount *, struct chfs_node_ref *,
 632     struct chfs_inode *);
 633 int chfs_makeinode(int, struct vnode *, struct vnode **,
 634     struct componentname *, int );
 635 void chfs_set_vnode_size(struct vnode *, size_t);
 636 void chfs_change_size_free(struct chfs_mount *,
 637         struct chfs_eraseblock *, int);
 638 void chfs_change_size_dirty(struct chfs_mount *,
 639         struct chfs_eraseblock *, int);
 640 void chfs_change_size_unchecked(struct chfs_mount *,
 641         struct chfs_eraseblock *, int);
 642 void chfs_change_size_used(struct chfs_mount *,
 643         struct chfs_eraseblock *, int);
 644 void chfs_change_size_wasted(struct chfs_mount *,
 645         struct chfs_eraseblock *, int);
 646
 647 /* chfs_vnode_cache.c */
 648 struct chfs_vnode_cache **chfs_vnocache_hash_init(void);
 649 void chfs_vnocache_hash_destroy(struct chfs_vnode_cache **);
 650 void chfs_vnode_cache_set_state(struct chfs_mount *,
 651     struct chfs_vnode_cache *, int);
 652 struct chfs_vnode_cache* chfs_vnode_cache_get(struct chfs_mount *, ino_t);
 653 void chfs_vnode_cache_add(struct chfs_mount *, struct chfs_vnode_cache *);
 654 void chfs_vnode_cache_remove(struct chfs_mount *, struct chfs_vnode_cache *);
 655
 656 /* chfs_wbuf.c */
 657 int chfs_write_wbuf(struct chfs_mount*,
 658     const struct iovec *, long, off_t, size_t *);
 659 int chfs_flush_pending_wbuf(struct chfs_mount *);
 660
 661 /* chfs_write.c */
 662 int chfs_write_flash_vnode(struct chfs_mount *, struct chfs_inode *, int);
 663 int chfs_write_flash_dirent(struct chfs_mount *, struct chfs_inode *,
 664     struct chfs_inode *, struct chfs_dirent *, ino_t, int);
 665 int chfs_write_flash_dnode(struct chfs_mount *, struct vnode *,
 666     struct buf *, struct chfs_full_dnode *);
 667 int chfs_do_link(struct chfs_inode *,
 668     struct chfs_inode *, const char *, int, enum vtype);
 669 int chfs_do_unlink(struct chfs_inode *,
 670     struct chfs_inode *, const char *, int);
 671
 672 /* chfs_subr.c */
 673 size_t chfs_mem_info(bool);
 674 struct chfs_dirent * chfs_dir_lookup(struct chfs_inode *,
 675     struct componentname *);
 676 int chfs_filldir (struct uio *, ino_t, const char *, int, enum vtype);
 677 int chfs_chsize(struct vnode *, u_quad_t, kauth_cred_t);
 678 int chfs_chflags(struct vnode *, int, kauth_cred_t);
 679 void chfs_itimes(struct chfs_inode *, const struct timespec *,
 680     const struct timespec *, const struct timespec *);
 681 int     chfs_update(struct vnode *, const struct timespec *,
 682     const struct timespec *, int);
 683 //int   chfs_truncate(struct vnode *, off_t);
 684
 685 /*---------------------------------------------------------------------------*/
 686
 687 /* Some inline functions temporarily placed here */
 688 static inline int
 689 chfs_map_leb(struct chfs_mount *chmp, int lnr)
 690 {
 691         int err;
 692
 693         err = ebh_map_leb(chmp->chm_ebh, lnr);
 694         if (err)
 695                 chfs_err("unmap leb %d failed, error: %d\n",lnr, err);
 696
 697         return err;
 698
 699 }
 700
 701 static inline int
 702 chfs_unmap_leb(struct chfs_mount *chmp, int lnr)
 703 {
 704         int err;
 705
 706         err = ebh_unmap_leb(chmp->chm_ebh, lnr);
 707         if (err)
 708                 chfs_err("unmap leb %d failed, error: %d\n",lnr, err);
 709
 710         return err;
 711 }
 712
 713 static inline int
 714 chfs_read_leb(struct chfs_mount *chmp, int lnr, char *buf,
 715     int offset, int len, size_t *retlen)
 716 {
 717         int err;
 718
 719         err = ebh_read_leb(chmp->chm_ebh, lnr, buf, offset, len, retlen);
 720         if (err)
 721                 chfs_err("read leb %d:%d failed, error: %d\n",
 722                     lnr, offset, err);
 723
 724         return err;
 725 }
 726
 727 static inline int chfs_write_leb(struct chfs_mount *chmp, int lnr, char *buf,
 728     int offset, int len, size_t *retlen)
 729 {
 730         int err;
 731         err = ebh_write_leb(chmp->chm_ebh, lnr, buf, offset, len, retlen);
 732         if (err)
 733                 chfs_err("write leb %d:%d failed, error: %d\n",
 734                     lnr, offset, err);
 735
 736         return err;
 737 }
 738
 739 /******************************************************************************/
 740 /* Code from dummyfs.h                                                                                                            */
 741 /******************************************************************************/
 742 /* --------------------------------------------------------------------- */
 743
 744 #define CHFS_PAGES_RESERVED (4 * 1024 * 1024 / PAGE_SIZE)
 745
 746 static __inline size_t
 747 CHFS_PAGES_MAX(struct chfs_mount *chmp)
 748 {
 749         size_t freepages;
 750
 751         freepages = chfs_mem_info(false);
 752         if (freepages < CHFS_PAGES_RESERVED)
 753                 freepages = 0;
 754         else
 755                 freepages -= CHFS_PAGES_RESERVED;
 756
 757         return MIN(chmp->chm_pages_max, freepages + chmp->chm_pages_used);
 758 }
 759
 760 #define CHFS_ITIMES(ip, acc, mod, cre)                                \
 761         while ((ip)->iflag & (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFY)) \
 762                 chfs_itimes(ip, acc, mod, cre)
 763
 764 /* used for KASSERTs */
 765 #define IMPLIES(a, b) (!(a) || (b))
 766 #define IFF(a, b) (IMPLIES(a, b) && IMPLIES(b, a))
 767
 768 #endif /* __CHFS_H__ */