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