1/* 2 * YAFFS: Yet another Flash File System . A NAND-flash specific file system. 3 * 4 * Copyright (C) 2002-2011 Aleph One Ltd. 5 * for Toby Churchill Ltd and Brightstar Engineering 6 * 7 * Created by Charles Manning <charles@aleph1.co.uk> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU Lesser General Public License version 2.1 as 11 * published by the Free Software Foundation. 12 * 13 * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. 14 */ 15 16#ifndef __YAFFS_GUTS_H__ 17#define __YAFFS_GUTS_H__ 18 19#include "yportenv.h" 20 21#define YAFFS_OK 1 22#define YAFFS_FAIL 0 23 24/* Give us a Y=0x59, 25 * Give us an A=0x41, 26 * Give us an FF=0xff 27 * Give us an S=0x53 28 * And what have we got... 29 */ 30#define YAFFS_MAGIC 0x5941ff53 31 32/* 33 * Tnodes form a tree with the tnodes in "levels" 34 * Levels greater than 0 hold 8 slots which point to other tnodes. 35 * Those at level 0 hold 16 slots which point to chunks in NAND. 36 * 37 * A maximum level of 8 thust supports files of size up to: 38 * 39 * 2^(3*MAX_LEVEL+4) 40 * 41 * Thus a max level of 8 supports files with up to 2^^28 chunks which gives 42 * a maximum file size of around 512Gbytees with 2k chunks. 43 */ 44#define YAFFS_NTNODES_LEVEL0 16 45#define YAFFS_TNODES_LEVEL0_BITS 4 46#define YAFFS_TNODES_LEVEL0_MASK 0xf 47 48#define YAFFS_NTNODES_INTERNAL (YAFFS_NTNODES_LEVEL0 / 2) 49#define YAFFS_TNODES_INTERNAL_BITS (YAFFS_TNODES_LEVEL0_BITS - 1) 50#define YAFFS_TNODES_INTERNAL_MASK 0x7 51#define YAFFS_TNODES_MAX_LEVEL 8 52#define YAFFS_TNODES_MAX_BITS (YAFFS_TNODES_LEVEL0_BITS + \ 53 YAFFS_TNODES_INTERNAL_BITS * \ 54 YAFFS_TNODES_MAX_LEVEL) 55#define YAFFS_MAX_CHUNK_ID ((1 << YAFFS_TNODES_MAX_BITS) - 1) 56 57#define YAFFS_MAX_FILE_SIZE_32 0x7fffffff 58 59/* Constants for YAFFS1 mode */ 60#define YAFFS_BYTES_PER_SPARE 16 61#define YAFFS_BYTES_PER_CHUNK 512 62#define YAFFS_CHUNK_SIZE_SHIFT 9 63#define YAFFS_CHUNKS_PER_BLOCK 32 64#define YAFFS_BYTES_PER_BLOCK (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK) 65 66#define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024 67#define YAFFS_MIN_YAFFS2_SPARE_SIZE 32 68 69 70 71#define YAFFS_ALLOCATION_NOBJECTS 100 72#define YAFFS_ALLOCATION_NTNODES 100 73#define YAFFS_ALLOCATION_NLINKS 100 74 75#define YAFFS_NOBJECT_BUCKETS 256 76 77#define YAFFS_OBJECT_SPACE 0x40000 78#define YAFFS_MAX_OBJECT_ID (YAFFS_OBJECT_SPACE - 1) 79 80/* Binary data version stamps */ 81#define YAFFS_SUMMARY_VERSION 1 82#define YAFFS_CHECKPOINT_VERSION 7 83 84#ifdef CONFIG_YAFFS_UNICODE 85#define YAFFS_MAX_NAME_LENGTH 127 86#define YAFFS_MAX_ALIAS_LENGTH 79 87#else 88#define YAFFS_MAX_NAME_LENGTH 255 89#define YAFFS_MAX_ALIAS_LENGTH 159 90#endif 91 92#define YAFFS_SHORT_NAME_LENGTH 15 93 94/* Some special object ids for pseudo objects */ 95#define YAFFS_OBJECTID_ROOT 1 96#define YAFFS_OBJECTID_LOSTNFOUND 2 97#define YAFFS_OBJECTID_UNLINKED 3 98#define YAFFS_OBJECTID_DELETED 4 99 100/* Fake object Id for summary data */ 101#define YAFFS_OBJECTID_SUMMARY 0x10 102 103/* Pseudo object ids for checkpointing */ 104#define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20 105#define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21 106 107#define YAFFS_MAX_SHORT_OP_CACHES 20 108 109#define YAFFS_N_TEMP_BUFFERS 6 110 111/* We limit the number attempts at sucessfully saving a chunk of data. 112 * Small-page devices have 32 pages per block; large-page devices have 64. 113 * Default to something in the order of 5 to 10 blocks worth of chunks. 114 */ 115#define YAFFS_WR_ATTEMPTS (5*64) 116 117/* Sequence numbers are used in YAFFS2 to determine block allocation order. 118 * The range is limited slightly to help distinguish bad numbers from good. 119 * This also allows us to perhaps in the future use special numbers for 120 * special purposes. 121 * EFFFFF00 allows the allocation of 8 blocks/second (~1Mbytes) for 15 years, 122 * and is a larger number than the lifetime of a 2GB device. 123 */ 124#define YAFFS_LOWEST_SEQUENCE_NUMBER 0x00001000 125#define YAFFS_HIGHEST_SEQUENCE_NUMBER 0xefffff00 126 127/* Special sequence number for bad block that failed to be marked bad */ 128#define YAFFS_SEQUENCE_BAD_BLOCK 0xffff0000 129 130/* ChunkCache is used for short read/write operations.*/ 131struct yaffs_cache { 132 struct yaffs_obj *object; 133 int chunk_id; 134 int last_use; 135 int dirty; 136 int n_bytes; /* Only valid if the cache is dirty */ 137 int locked; /* Can't push out or flush while locked. */ 138 u8 *data; 139}; 140 141/* yaffs1 tags structures in RAM 142 * NB This uses bitfield. Bitfields should not straddle a u32 boundary 143 * otherwise the structure size will get blown out. 144 */ 145 146struct yaffs_tags { 147 u32 chunk_id:20; 148 u32 serial_number:2; 149 u32 n_bytes_lsb:10; 150 u32 obj_id:18; 151 u32 ecc:12; 152 u32 n_bytes_msb:2; 153}; 154 155union yaffs_tags_union { 156 struct yaffs_tags as_tags; 157 u8 as_bytes[8]; 158}; 159 160 161/* Stuff used for extended tags in YAFFS2 */ 162 163enum yaffs_ecc_result { 164 YAFFS_ECC_RESULT_UNKNOWN, 165 YAFFS_ECC_RESULT_NO_ERROR, 166 YAFFS_ECC_RESULT_FIXED, 167 YAFFS_ECC_RESULT_UNFIXED 168}; 169 170enum yaffs_obj_type { 171 YAFFS_OBJECT_TYPE_UNKNOWN, 172 YAFFS_OBJECT_TYPE_FILE, 173 YAFFS_OBJECT_TYPE_SYMLINK, 174 YAFFS_OBJECT_TYPE_DIRECTORY, 175 YAFFS_OBJECT_TYPE_HARDLINK, 176 YAFFS_OBJECT_TYPE_SPECIAL 177}; 178 179#define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL 180 181struct yaffs_ext_tags { 182 unsigned chunk_used; /* Status of the chunk: used or unused */ 183 unsigned obj_id; /* If 0 this is not used */ 184 unsigned chunk_id; /* If 0 this is a header, else a data chunk */ 185 unsigned n_bytes; /* Only valid for data chunks */ 186 187 /* The following stuff only has meaning when we read */ 188 enum yaffs_ecc_result ecc_result; 189 unsigned block_bad; 190 191 /* YAFFS 1 stuff */ 192 unsigned is_deleted; /* The chunk is marked deleted */ 193 unsigned serial_number; /* Yaffs1 2-bit serial number */ 194 195 /* YAFFS2 stuff */ 196 unsigned seq_number; /* The sequence number of this block */ 197 198 /* Extra info if this is an object header (YAFFS2 only) */ 199 200 unsigned extra_available; /* Extra info available if not zero */ 201 unsigned extra_parent_id; /* The parent object */ 202 unsigned extra_is_shrink; /* Is it a shrink header? */ 203 unsigned extra_shadows; /* Does this shadow another object? */ 204 205 enum yaffs_obj_type extra_obj_type; /* What object type? */ 206 207 loff_t extra_file_size; /* Length if it is a file */ 208 unsigned extra_equiv_id; /* Equivalent object for a hard link */ 209}; 210 211/* Spare structure for YAFFS1 */ 212struct yaffs_spare { 213 u8 tb0; 214 u8 tb1; 215 u8 tb2; 216 u8 tb3; 217 u8 page_status; /* set to 0 to delete the chunk */ 218 u8 block_status; 219 u8 tb4; 220 u8 tb5; 221 u8 ecc1[3]; 222 u8 tb6; 223 u8 tb7; 224 u8 ecc2[3]; 225}; 226 227/*Special structure for passing through to mtd */ 228struct yaffs_nand_spare { 229 struct yaffs_spare spare; 230 int eccres1; 231 int eccres2; 232}; 233 234/* Block data in RAM */ 235 236enum yaffs_block_state { 237 YAFFS_BLOCK_STATE_UNKNOWN = 0, 238 239 YAFFS_BLOCK_STATE_SCANNING, 240 /* Being scanned */ 241 242 YAFFS_BLOCK_STATE_NEEDS_SCAN, 243 /* The block might have something on it (ie it is allocating or full, 244 * perhaps empty) but it needs to be scanned to determine its true 245 * state. 246 * This state is only valid during scanning. 247 * NB We tolerate empty because the pre-scanner might be incapable of 248 * deciding 249 * However, if this state is returned on a YAFFS2 device, 250 * then we expect a sequence number 251 */ 252 253 YAFFS_BLOCK_STATE_EMPTY, 254 /* This block is empty */ 255 256 YAFFS_BLOCK_STATE_ALLOCATING, 257 /* This block is partially allocated. 258 * At least one page holds valid data. 259 * This is the one currently being used for page 260 * allocation. Should never be more than one of these. 261 * If a block is only partially allocated at mount it is treated as 262 * full. 263 */ 264 265 YAFFS_BLOCK_STATE_FULL, 266 /* All the pages in this block have been allocated. 267 * If a block was only partially allocated when mounted we treat 268 * it as fully allocated. 269 */ 270 271 YAFFS_BLOCK_STATE_DIRTY, 272 /* The block was full and now all chunks have been deleted. 273 * Erase me, reuse me. 274 */ 275 276 YAFFS_BLOCK_STATE_CHECKPOINT, 277 /* This block is assigned to holding checkpoint data. */ 278 279 YAFFS_BLOCK_STATE_COLLECTING, 280 /* This block is being garbage collected */ 281 282 YAFFS_BLOCK_STATE_DEAD 283 /* This block has failed and is not in use */ 284}; 285 286#define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) 287 288struct yaffs_block_info { 289 290 s32 soft_del_pages:10; /* number of soft deleted pages */ 291 s32 pages_in_use:10; /* number of pages in use */ 292 u32 block_state:4; /* One of the above block states. */ 293 /* NB use unsigned because enum is sometimes 294 * an int */ 295 u32 needs_retiring:1; /* Data has failed on this block, */ 296 /*need to get valid data off and retire*/ 297 u32 skip_erased_check:1;/* Skip the erased check on this block */ 298 u32 gc_prioritise:1; /* An ECC check or blank check has failed. 299 Block should be prioritised for GC */ 300 u32 chunk_error_strikes:3; /* How many times we've had ecc etc 301 failures on this block and tried to reuse it */ 302 u32 has_summary:1; /* The block has a summary */ 303 304 u32 has_shrink_hdr:1; /* This block has at least one shrink header */ 305 u32 seq_number; /* block sequence number for yaffs2 */ 306 307}; 308 309/* -------------------------- Object structure -------------------------------*/ 310/* This is the object structure as stored on NAND */ 311 312struct yaffs_obj_hdr { 313 enum yaffs_obj_type type; 314 315 /* Apply to everything */ 316 int parent_obj_id; 317 u16 sum_no_longer_used; /* checksum of name. No longer used */ 318 YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; 319 320 /* The following apply to all object types except for hard links */ 321 u32 yst_mode; /* protection */ 322 323 u32 yst_uid; 324 u32 yst_gid; 325 u32 yst_atime; 326 u32 yst_mtime; 327 u32 yst_ctime; 328 329 /* File size applies to files only */ 330 u32 file_size_low; 331 332 /* Equivalent object id applies to hard links only. */ 333 int equiv_id; 334 335 /* Alias is for symlinks only. */ 336 YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; 337 338 u32 yst_rdev; /* stuff for block and char devices (major/min) */ 339 340 u32 win_ctime[2]; 341 u32 win_atime[2]; 342 u32 win_mtime[2]; 343 344 u32 inband_shadowed_obj_id; 345 u32 inband_is_shrink; 346 347 u32 file_size_high; 348 u32 reserved[1]; 349 int shadows_obj; /* This object header shadows the 350 specified object if > 0 */ 351 352 /* is_shrink applies to object headers written when wemake a hole. */ 353 u32 is_shrink; 354 355}; 356 357/*--------------------------- Tnode -------------------------- */ 358 359struct yaffs_tnode { 360 struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL]; 361}; 362 363/*------------------------ Object -----------------------------*/ 364/* An object can be one of: 365 * - a directory (no data, has children links 366 * - a regular file (data.... not prunes :->). 367 * - a symlink [symbolic link] (the alias). 368 * - a hard link 369 */ 370 371struct yaffs_file_var { 372 loff_t file_size; 373 loff_t scanned_size; 374 loff_t shrink_size; 375 int top_level; 376 struct yaffs_tnode *top; 377}; 378 379struct yaffs_dir_var { 380 struct list_head children; /* list of child links */ 381 struct list_head dirty; /* Entry for list of dirty directories */ 382}; 383 384struct yaffs_symlink_var { 385 YCHAR *alias; 386}; 387 388struct yaffs_hardlink_var { 389 struct yaffs_obj *equiv_obj; 390 u32 equiv_id; 391}; 392 393union yaffs_obj_var { 394 struct yaffs_file_var file_variant; 395 struct yaffs_dir_var dir_variant; 396 struct yaffs_symlink_var symlink_variant; 397 struct yaffs_hardlink_var hardlink_variant; 398}; 399 400struct yaffs_obj { 401 u8 deleted:1; /* This should only apply to unlinked files. */ 402 u8 soft_del:1; /* it has also been soft deleted */ 403 u8 unlinked:1; /* An unlinked file.*/ 404 u8 fake:1; /* A fake object has no presence on NAND. */ 405 u8 rename_allowed:1; /* Some objects cannot be renamed. */ 406 u8 unlink_allowed:1; 407 u8 dirty:1; /* the object needs to be written to flash */ 408 u8 valid:1; /* When the file system is being loaded up, this 409 * object might be created before the data 410 * is available 411 * ie. file data chunks encountered before 412 * the header. 413 */ 414 u8 lazy_loaded:1; /* This object has been lazy loaded and 415 * is missing some detail */ 416 417 u8 defered_free:1; /* Object is removed from NAND, but is 418 * still in the inode cache. 419 * Free of object is defered. 420 * until the inode is released. 421 */ 422 u8 being_created:1; /* This object is still being created 423 * so skip some verification checks. */ 424 u8 is_shadowed:1; /* This object is shadowed on the way 425 * to being renamed. */ 426 427 u8 xattr_known:1; /* We know if this has object has xattribs 428 * or not. */ 429 u8 has_xattr:1; /* This object has xattribs. 430 * Only valid if xattr_known. */ 431 432 u8 serial; /* serial number of chunk in NAND.*/ 433 u16 sum; /* sum of the name to speed searching */ 434 435 struct yaffs_dev *my_dev; /* The device I'm on */ 436 437 struct list_head hash_link; /* list of objects in hash bucket */ 438 439 struct list_head hard_links; /* hard linked object chain*/ 440 441 /* directory structure stuff */ 442 /* also used for linking up the free list */ 443 struct yaffs_obj *parent; 444 struct list_head siblings; 445 446 /* Where's my object header in NAND? */ 447 int hdr_chunk; 448 449 int n_data_chunks; /* Number of data chunks for this file. */ 450 451 u32 obj_id; /* the object id value */ 452 453 u32 yst_mode; 454 455 YCHAR short_name[YAFFS_SHORT_NAME_LENGTH + 1]; 456 457#ifdef CONFIG_YAFFS_WINCE 458 u32 win_ctime[2]; 459 u32 win_mtime[2]; 460 u32 win_atime[2]; 461#else 462 u32 yst_uid; 463 u32 yst_gid; 464 u32 yst_atime; 465 u32 yst_mtime; 466 u32 yst_ctime; 467#endif 468 469 u32 yst_rdev; 470 471 void *my_inode; 472 473 enum yaffs_obj_type variant_type; 474 475 union yaffs_obj_var variant; 476 477}; 478 479struct yaffs_obj_bucket { 480 struct list_head list; 481 int count; 482}; 483 484/* yaffs_checkpt_obj holds the definition of an object as dumped 485 * by checkpointing. 486 */ 487 488struct yaffs_checkpt_obj { 489 int struct_type; 490 u32 obj_id; 491 u32 parent_id; 492 int hdr_chunk; 493 enum yaffs_obj_type variant_type:3; 494 u8 deleted:1; 495 u8 soft_del:1; 496 u8 unlinked:1; 497 u8 fake:1; 498 u8 rename_allowed:1; 499 u8 unlink_allowed:1; 500 u8 serial; 501 int n_data_chunks; 502 loff_t size_or_equiv_obj; 503}; 504 505/*--------------------- Temporary buffers ---------------- 506 * 507 * These are chunk-sized working buffers. Each device has a few. 508 */ 509 510struct yaffs_buffer { 511 u8 *buffer; 512 int in_use; 513}; 514 515/*----------------- Device ---------------------------------*/ 516 517struct yaffs_param { 518 const YCHAR *name; 519 520 /* 521 * Entry parameters set up way early. Yaffs sets up the rest. 522 * The structure should be zeroed out before use so that unused 523 * and default values are zero. 524 */ 525 526 int inband_tags; /* Use unband tags */ 527 u32 total_bytes_per_chunk; /* Should be >= 512, does not need to 528 be a power of 2 */ 529 int chunks_per_block; /* does not need to be a power of 2 */ 530 int spare_bytes_per_chunk; /* spare area size */ 531 int start_block; /* Start block we're allowed to use */ 532 int end_block; /* End block we're allowed to use */ 533 int n_reserved_blocks; /* Tuneable so that we can reduce 534 * reserved blocks on NOR and RAM. */ 535 536 int n_caches; /* If <= 0, then short op caching is disabled, 537 * else the number of short op caches. 538 */ 539 int cache_bypass_aligned; /* If non-zero then bypass the cache for 540 * aligned writes. 541 */ 542 543 int use_nand_ecc; /* Flag to decide whether or not to use 544 * NAND driver ECC on data (yaffs1) */ 545 int tags_9bytes; /* Use 9 byte tags */ 546 int no_tags_ecc; /* Flag to decide whether or not to do ECC 547 * on packed tags (yaffs2) */ 548 549 int is_yaffs2; /* Use yaffs2 mode on this device */ 550 551 int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ 552 553 int refresh_period; /* How often to check for a block refresh */ 554 555 /* Checkpoint control. Can be set before or after initialisation */ 556 u8 skip_checkpt_rd; 557 u8 skip_checkpt_wr; 558 559 int enable_xattr; /* Enable xattribs */ 560 561 int max_objects; /* 562 * Set to limit the number of objects created. 563 * 0 = no limit. 564 */ 565 566 /* The remove_obj_fn function must be supplied by OS flavours that 567 * need it. 568 * yaffs direct uses it to implement the faster readdir. 569 * Linux uses it to protect the directory during unlocking. 570 */ 571 void (*remove_obj_fn) (struct yaffs_obj *obj); 572 573 /* Callback to mark the superblock dirty */ 574 void (*sb_dirty_fn) (struct yaffs_dev *dev); 575 576 /* Callback to control garbage collection. */ 577 unsigned (*gc_control_fn) (struct yaffs_dev *dev); 578 579 /* Debug control flags. Don't use unless you know what you're doing */ 580 int use_header_file_size; /* Flag to determine if we should use 581 * file sizes from the header */ 582 int disable_lazy_load; /* Disable lazy loading on this device */ 583 int wide_tnodes_disabled; /* Set to disable wide tnodes */ 584 int disable_soft_del; /* yaffs 1 only: Set to disable the use of 585 * softdeletion. */ 586 587 int defered_dir_update; /* Set to defer directory updates */ 588 589#ifdef CONFIG_YAFFS_AUTO_UNICODE 590 int auto_unicode; 591#endif 592 int always_check_erased; /* Force chunk erased check always on */ 593 594 int disable_summary; 595 int disable_bad_block_marking; 596 597}; 598 599struct yaffs_driver { 600 int (*drv_write_chunk_fn) (struct yaffs_dev *dev, int nand_chunk, 601 const u8 *data, int data_len, 602 const u8 *oob, int oob_len); 603 int (*drv_read_chunk_fn) (struct yaffs_dev *dev, int nand_chunk, 604 u8 *data, int data_len, 605 u8 *oob, int oob_len, 606 enum yaffs_ecc_result *ecc_result); 607 int (*drv_erase_fn) (struct yaffs_dev *dev, int block_no); 608 int (*drv_mark_bad_fn) (struct yaffs_dev *dev, int block_no); 609 int (*drv_check_bad_fn) (struct yaffs_dev *dev, int block_no); 610 int (*drv_initialise_fn) (struct yaffs_dev *dev); 611 int (*drv_deinitialise_fn) (struct yaffs_dev *dev); 612}; 613 614struct yaffs_tags_handler { 615 int (*write_chunk_tags_fn) (struct yaffs_dev *dev, 616 int nand_chunk, const u8 *data, 617 const struct yaffs_ext_tags *tags); 618 int (*read_chunk_tags_fn) (struct yaffs_dev *dev, 619 int nand_chunk, u8 *data, 620 struct yaffs_ext_tags *tags); 621 622 int (*query_block_fn) (struct yaffs_dev *dev, int block_no, 623 enum yaffs_block_state *state, 624 u32 *seq_number); 625 int (*mark_bad_fn) (struct yaffs_dev *dev, int block_no); 626}; 627 628struct yaffs_dev { 629 struct yaffs_param param; 630 struct yaffs_driver drv; 631 struct yaffs_tags_handler tagger; 632 633 /* Context storage. Holds extra OS specific data for this device */ 634 635 void *os_context; 636 void *driver_context; 637 638 struct list_head dev_list; 639 640 int ll_init; 641 /* Runtime parameters. Set up by YAFFS. */ 642 int data_bytes_per_chunk; 643 644 /* Non-wide tnode stuff */ 645 u16 chunk_grp_bits; /* Number of bits that need to be resolved if 646 * the tnodes are not wide enough. 647 */ 648 u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ 649 650 /* Stuff to support wide tnodes */ 651 u32 tnode_width; 652 u32 tnode_mask; 653 u32 tnode_size; 654 655 /* Stuff for figuring out file offset to chunk conversions */ 656 u32 chunk_shift; /* Shift value */ 657 u32 chunk_div; /* Divisor after shifting: 1 for 2^n sizes */ 658 u32 chunk_mask; /* Mask to use for power-of-2 case */ 659 660 int is_mounted; 661 int read_only; 662 int is_checkpointed; 663 664 /* Stuff to support block offsetting to support start block zero */ 665 int internal_start_block; 666 int internal_end_block; 667 int block_offset; 668 int chunk_offset; 669 670 /* Runtime checkpointing stuff */ 671 int checkpt_page_seq; /* running sequence number of checkpt pages */ 672 int checkpt_byte_count; 673 int checkpt_byte_offs; 674 u8 *checkpt_buffer; 675 int checkpt_open_write; 676 int blocks_in_checkpt; 677 int checkpt_cur_chunk; 678 int checkpt_cur_block; 679 int checkpt_next_block; 680 int *checkpt_block_list; 681 int checkpt_max_blocks; 682 u32 checkpt_sum; 683 u32 checkpt_xor; 684 685 int checkpoint_blocks_required; /* Number of blocks needed to store 686 * current checkpoint set */ 687 688 /* Block Info */ 689 struct yaffs_block_info *block_info; 690 u8 *chunk_bits; /* bitmap of chunks in use */ 691 u8 block_info_alt:1; /* allocated using alternative alloc */ 692 u8 chunk_bits_alt:1; /* allocated using alternative alloc */ 693 int chunk_bit_stride; /* Number of bytes of chunk_bits per block. 694 * Must be consistent with chunks_per_block. 695 */ 696 697 int n_erased_blocks; 698 int alloc_block; /* Current block being allocated off */ 699 u32 alloc_page; 700 int alloc_block_finder; /* Used to search for next allocation block */ 701 702 /* Object and Tnode memory management */ 703 void *allocator; 704 int n_obj; 705 int n_tnodes; 706 707 int n_hardlinks; 708 709 struct yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; 710 u32 bucket_finder; 711 712 int n_free_chunks; 713 714 /* Garbage collection control */ 715 u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ 716 u32 n_clean_ups; 717 718 unsigned has_pending_prioritised_gc; /* We think this device might 719 have pending prioritised gcs */ 720 unsigned gc_disable; 721 unsigned gc_block_finder; 722 unsigned gc_dirtiest; 723 unsigned gc_pages_in_use; 724 unsigned gc_not_done; 725 unsigned gc_block; 726 unsigned gc_chunk; 727 unsigned gc_skip; 728 struct yaffs_summary_tags *gc_sum_tags; 729 730 /* Special directories */ 731 struct yaffs_obj *root_dir; 732 struct yaffs_obj *lost_n_found; 733 734 int buffered_block; /* Which block is buffered here? */ 735 int doing_buffered_block_rewrite; 736 737 struct yaffs_cache *cache; 738 int cache_last_use; 739 740 /* Stuff for background deletion and unlinked files. */ 741 struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted 742 files live. */ 743 struct yaffs_obj *del_dir; /* Directory where deleted objects are 744 sent to disappear. */ 745 struct yaffs_obj *unlinked_deletion; /* Current file being 746 background deleted. */ 747 int n_deleted_files; /* Count of files awaiting deletion; */ 748 int n_unlinked_files; /* Count of unlinked files. */ 749 int n_bg_deletions; /* Count of background deletions. */ 750 751 /* Temporary buffer management */ 752 struct yaffs_buffer temp_buffer[YAFFS_N_TEMP_BUFFERS]; 753 int max_temp; 754 int temp_in_use; 755 int unmanaged_buffer_allocs; 756 int unmanaged_buffer_deallocs; 757 758 /* yaffs2 runtime stuff */ 759 unsigned seq_number; /* Sequence number of currently 760 allocating block */ 761 unsigned oldest_dirty_seq; 762 unsigned oldest_dirty_block; 763 764 /* Block refreshing */ 765 int refresh_skip; /* A skip down counter. 766 * Refresh happens when this gets to zero. */ 767 768 /* Dirty directory handling */ 769 struct list_head dirty_dirs; /* List of dirty directories */ 770 771 /* Summary */ 772 int chunks_per_summary; 773 struct yaffs_summary_tags *sum_tags; 774 775 /* Statistics */ 776 u32 n_page_writes; 777 u32 n_page_reads; 778 u32 n_erasures; 779 u32 n_bad_queries; 780 u32 n_bad_markings; 781 u32 n_erase_failures; 782 u32 n_gc_copies; 783 u32 all_gcs; 784 u32 passive_gc_count; 785 u32 oldest_dirty_gc_count; 786 u32 n_gc_blocks; 787 u32 bg_gcs; 788 u32 n_retried_writes; 789 u32 n_retired_blocks; 790 u32 n_ecc_fixed; 791 u32 n_ecc_unfixed; 792 u32 n_tags_ecc_fixed; 793 u32 n_tags_ecc_unfixed; 794 u32 n_deletions; 795 u32 n_unmarked_deletions; 796 u32 refresh_count; 797 u32 cache_hits; 798 u32 tags_used; 799 u32 summary_used; 800 801}; 802 803/* The CheckpointDevice structure holds the device information that changes 804 *at runtime and must be preserved over unmount/mount cycles. 805 */ 806struct yaffs_checkpt_dev { 807 int struct_type; 808 int n_erased_blocks; 809 int alloc_block; /* Current block being allocated off */ 810 u32 alloc_page; 811 int n_free_chunks; 812 813 int n_deleted_files; /* Count of files awaiting deletion; */ 814 int n_unlinked_files; /* Count of unlinked files. */ 815 int n_bg_deletions; /* Count of background deletions. */ 816 817 /* yaffs2 runtime stuff */ 818 unsigned seq_number; /* Sequence number of currently 819 * allocating block */ 820 821}; 822 823struct yaffs_checkpt_validity { 824 int struct_type; 825 u32 magic; 826 u32 version; 827 u32 head; 828}; 829 830struct yaffs_shadow_fixer { 831 int obj_id; 832 int shadowed_id; 833 struct yaffs_shadow_fixer *next; 834}; 835 836/* Structure for doing xattr modifications */ 837struct yaffs_xattr_mod { 838 int set; /* If 0 then this is a deletion */ 839 const YCHAR *name; 840 const void *data; 841 int size; 842 int flags; 843 int result; 844}; 845 846/*----------------------- YAFFS Functions -----------------------*/ 847 848int yaffs_guts_initialise(struct yaffs_dev *dev); 849void yaffs_deinitialise(struct yaffs_dev *dev); 850 851int yaffs_get_n_free_chunks(struct yaffs_dev *dev); 852 853int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, 854 struct yaffs_obj *new_dir, const YCHAR * new_name); 855 856int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name); 857int yaffs_del_obj(struct yaffs_obj *obj); 858struct yaffs_obj *yaffs_retype_obj(struct yaffs_obj *obj, 859 enum yaffs_obj_type type); 860 861 862int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size); 863loff_t yaffs_get_obj_length(struct yaffs_obj *obj); 864int yaffs_get_obj_inode(struct yaffs_obj *obj); 865unsigned yaffs_get_obj_type(struct yaffs_obj *obj); 866int yaffs_get_obj_link_count(struct yaffs_obj *obj); 867 868/* File operations */ 869int yaffs_file_rd(struct yaffs_obj *obj, u8 * buffer, loff_t offset, 870 int n_bytes); 871int yaffs_wr_file(struct yaffs_obj *obj, const u8 * buffer, loff_t offset, 872 int n_bytes, int write_trhrough); 873int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size); 874 875struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, 876 const YCHAR *name, u32 mode, u32 uid, 877 u32 gid); 878 879int yaffs_flush_file(struct yaffs_obj *in, 880 int update_time, 881 int data_sync, 882 int discard_cache); 883 884/* Flushing and checkpointing */ 885void yaffs_flush_whole_cache(struct yaffs_dev *dev, int discard); 886 887int yaffs_checkpoint_save(struct yaffs_dev *dev); 888int yaffs_checkpoint_restore(struct yaffs_dev *dev); 889 890/* Directory operations */ 891struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name, 892 u32 mode, u32 uid, u32 gid); 893struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, 894 const YCHAR *name); 895struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number); 896 897/* Link operations */ 898struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name, 899 struct yaffs_obj *equiv_obj); 900 901struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj); 902 903/* Symlink operations */ 904struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, 905 const YCHAR *name, u32 mode, u32 uid, 906 u32 gid, const YCHAR *alias); 907YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj); 908 909/* Special inodes (fifos, sockets and devices) */ 910struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, 911 const YCHAR *name, u32 mode, u32 uid, 912 u32 gid, u32 rdev); 913 914int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, 915 const void *value, int size, int flags); 916int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, 917 int size); 918int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size); 919int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name); 920 921/* Special directories */ 922struct yaffs_obj *yaffs_root(struct yaffs_dev *dev); 923struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev); 924 925void yaffs_handle_defered_free(struct yaffs_obj *obj); 926 927void yaffs_update_dirty_dirs(struct yaffs_dev *dev); 928 929int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency); 930 931/* Debug dump */ 932int yaffs_dump_obj(struct yaffs_obj *obj); 933 934void yaffs_guts_test(struct yaffs_dev *dev); 935int yaffs_guts_ll_init(struct yaffs_dev *dev); 936 937 938/* A few useful functions to be used within the core files*/ 939void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, 940 int lyn); 941int yaffs_check_ff(u8 *buffer, int n_bytes); 942void yaffs_handle_chunk_error(struct yaffs_dev *dev, 943 struct yaffs_block_info *bi); 944 945u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev); 946void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer); 947 948struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, 949 int number, 950 enum yaffs_obj_type type); 951int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, 952 int nand_chunk, int in_scan); 953void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name); 954void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, 955 const struct yaffs_obj_hdr *oh); 956void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj); 957YCHAR *yaffs_clone_str(const YCHAR *str); 958void yaffs_link_fixup(struct yaffs_dev *dev, struct list_head *hard_list); 959void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no); 960int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, 961 int force, int is_shrink, int shadows, 962 struct yaffs_xattr_mod *xop); 963void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, 964 int backward_scanning); 965int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks); 966struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev); 967struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, 968 struct yaffs_file_var *file_struct, 969 u32 chunk_id, 970 struct yaffs_tnode *passed_tn); 971 972int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, 973 int n_bytes, int write_trhrough); 974void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size); 975void yaffs_skip_rest_of_block(struct yaffs_dev *dev); 976 977int yaffs_count_free_chunks(struct yaffs_dev *dev); 978 979struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, 980 struct yaffs_file_var *file_struct, 981 u32 chunk_id); 982 983u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, 984 unsigned pos); 985 986int yaffs_is_non_empty_dir(struct yaffs_obj *obj); 987 988int yaffs_guts_format_dev(struct yaffs_dev *dev); 989 990void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, 991 int *chunk_out, u32 *offset_out); 992/* 993 * Marshalling functions to get loff_t file sizes into aand out of 994 * object headers. 995 */ 996void yaffs_oh_size_load(struct yaffs_obj_hdr *oh, loff_t fsize); 997loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh); 998loff_t yaffs_max_file_size(struct yaffs_dev *dev); 999 1000/* 1001 * Debug function to count number of blocks in each state 1002 * NB Needs to be called with correct number of integers 1003 */ 1004 1005void yaffs_count_blocks_by_state(struct yaffs_dev *dev, int bs[10]); 1006 1007int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, 1008 struct yaffs_ext_tags *tags); 1009 1010#endif 1011