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.*/ 131 struct 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 146 struct yaffs_tags { 147 unsigned chunk_id:20; 148 unsigned serial_number:2; 149 unsigned n_bytes_lsb:10; 150 unsigned obj_id:18; 151 unsigned ecc:12; 152 unsigned n_bytes_msb:2; 153 }; 154 155 union 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 163 enum 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 170 enum 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 181 struct 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 */ 212 struct 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 */ 228 struct yaffs_nand_spare { 229 struct yaffs_spare spare; 230 int eccres1; 231 int eccres2; 232 }; 233 234 /* Block data in RAM */ 235 236 enum 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 288 struct yaffs_block_info { 289 290 int soft_del_pages:10; /* number of soft deleted pages */ 291 int pages_in_use:10; /* number of pages in use */ 292 unsigned 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 312 struct 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 359 struct 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 371 struct 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 379 struct 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 384 struct yaffs_symlink_var { 385 YCHAR *alias; 386 }; 387 388 struct yaffs_hardlink_var { 389 struct yaffs_obj *equiv_obj; 390 u32 equiv_id; 391 }; 392 393 union 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 400 struct 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 479 struct 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 488 struct 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 510 struct yaffs_buffer { 511 u8 *buffer; 512 int in_use; 513 }; 514 515 /*----------------- Device ---------------------------------*/ 516 517 struct 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 596 }; 597 598 struct yaffs_driver { 599 int (*drv_write_chunk_fn) (struct yaffs_dev *dev, int nand_chunk, 600 const u8 *data, int data_len, 601 const u8 *oob, int oob_len); 602 int (*drv_read_chunk_fn) (struct yaffs_dev *dev, int nand_chunk, 603 u8 *data, int data_len, 604 u8 *oob, int oob_len, 605 enum yaffs_ecc_result *ecc_result); 606 int (*drv_erase_fn) (struct yaffs_dev *dev, int block_no); 607 int (*drv_mark_bad_fn) (struct yaffs_dev *dev, int block_no); 608 int (*drv_check_bad_fn) (struct yaffs_dev *dev, int block_no); 609 int (*drv_initialise_fn) (struct yaffs_dev *dev); 610 int (*drv_deinitialise_fn) (struct yaffs_dev *dev); 611 }; 612 613 struct yaffs_tags_handler { 614 int (*write_chunk_tags_fn) (struct yaffs_dev *dev, 615 int nand_chunk, const u8 *data, 616 const struct yaffs_ext_tags *tags); 617 int (*read_chunk_tags_fn) (struct yaffs_dev *dev, 618 int nand_chunk, u8 *data, 619 struct yaffs_ext_tags *tags); 620 621 int (*query_block_fn) (struct yaffs_dev *dev, int block_no, 622 enum yaffs_block_state *state, 623 u32 *seq_number); 624 int (*mark_bad_fn) (struct yaffs_dev *dev, int block_no); 625 }; 626 627 struct yaffs_dev { 628 struct yaffs_param param; 629 struct yaffs_driver drv; 630 struct yaffs_tags_handler tagger; 631 632 /* Context storage. Holds extra OS specific data for this device */ 633 634 void *os_context; 635 void *driver_context; 636 637 struct list_head dev_list; 638 639 /* Runtime parameters. Set up by YAFFS. */ 640 int data_bytes_per_chunk; 641 642 /* Non-wide tnode stuff */ 643 u16 chunk_grp_bits; /* Number of bits that need to be resolved if 644 * the tnodes are not wide enough. 645 */ 646 u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ 647 648 /* Stuff to support wide tnodes */ 649 u32 tnode_width; 650 u32 tnode_mask; 651 u32 tnode_size; 652 653 /* Stuff for figuring out file offset to chunk conversions */ 654 u32 chunk_shift; /* Shift value */ 655 u32 chunk_div; /* Divisor after shifting: 1 for 2^n sizes */ 656 u32 chunk_mask; /* Mask to use for power-of-2 case */ 657 658 int is_mounted; 659 int read_only; 660 int is_checkpointed; 661 662 /* Stuff to support block offsetting to support start block zero */ 663 int internal_start_block; 664 int internal_end_block; 665 int block_offset; 666 int chunk_offset; 667 668 /* Runtime checkpointing stuff */ 669 int checkpt_page_seq; /* running sequence number of checkpt pages */ 670 int checkpt_byte_count; 671 int checkpt_byte_offs; 672 u8 *checkpt_buffer; 673 int checkpt_open_write; 674 int blocks_in_checkpt; 675 int checkpt_cur_chunk; 676 int checkpt_cur_block; 677 int checkpt_next_block; 678 int *checkpt_block_list; 679 int checkpt_max_blocks; 680 u32 checkpt_sum; 681 u32 checkpt_xor; 682 683 int checkpoint_blocks_required; /* Number of blocks needed to store 684 * current checkpoint set */ 685 686 /* Block Info */ 687 struct yaffs_block_info *block_info; 688 u8 *chunk_bits; /* bitmap of chunks in use */ 689 unsigned block_info_alt:1; /* allocated using alternative alloc */ 690 unsigned chunk_bits_alt:1; /* allocated using alternative alloc */ 691 int chunk_bit_stride; /* Number of bytes of chunk_bits per block. 692 * Must be consistent with chunks_per_block. 693 */ 694 695 int n_erased_blocks; 696 int alloc_block; /* Current block being allocated off */ 697 u32 alloc_page; 698 int alloc_block_finder; /* Used to search for next allocation block */ 699 700 /* Object and Tnode memory management */ 701 void *allocator; 702 int n_obj; 703 int n_tnodes; 704 705 int n_hardlinks; 706 707 struct yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; 708 u32 bucket_finder; 709 710 int n_free_chunks; 711 712 /* Garbage collection control */ 713 u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ 714 u32 n_clean_ups; 715 716 unsigned has_pending_prioritised_gc; /* We think this device might 717 have pending prioritised gcs */ 718 unsigned gc_disable; 719 unsigned gc_block_finder; 720 unsigned gc_dirtiest; 721 unsigned gc_pages_in_use; 722 unsigned gc_not_done; 723 unsigned gc_block; 724 unsigned gc_chunk; 725 unsigned gc_skip; 726 struct yaffs_summary_tags *gc_sum_tags; 727 728 /* Special directories */ 729 struct yaffs_obj *root_dir; 730 struct yaffs_obj *lost_n_found; 731 732 int buffered_block; /* Which block is buffered here? */ 733 int doing_buffered_block_rewrite; 734 735 struct yaffs_cache *cache; 736 int cache_last_use; 737 738 /* Stuff for background deletion and unlinked files. */ 739 struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted 740 files live. */ 741 struct yaffs_obj *del_dir; /* Directory where deleted objects are 742 sent to disappear. */ 743 struct yaffs_obj *unlinked_deletion; /* Current file being 744 background deleted. */ 745 int n_deleted_files; /* Count of files awaiting deletion; */ 746 int n_unlinked_files; /* Count of unlinked files. */ 747 int n_bg_deletions; /* Count of background deletions. */ 748 749 /* Temporary buffer management */ 750 struct yaffs_buffer temp_buffer[YAFFS_N_TEMP_BUFFERS]; 751 int max_temp; 752 int temp_in_use; 753 int unmanaged_buffer_allocs; 754 int unmanaged_buffer_deallocs; 755 756 /* yaffs2 runtime stuff */ 757 unsigned seq_number; /* Sequence number of currently 758 allocating block */ 759 unsigned oldest_dirty_seq; 760 unsigned oldest_dirty_block; 761 762 /* Block refreshing */ 763 int refresh_skip; /* A skip down counter. 764 * Refresh happens when this gets to zero. */ 765 766 /* Dirty directory handling */ 767 struct list_head dirty_dirs; /* List of dirty directories */ 768 769 /* Summary */ 770 int chunks_per_summary; 771 struct yaffs_summary_tags *sum_tags; 772 773 /* Statistics */ 774 u32 n_page_writes; 775 u32 n_page_reads; 776 u32 n_erasures; 777 u32 n_bad_markings; 778 u32 n_erase_failures; 779 u32 n_gc_copies; 780 u32 all_gcs; 781 u32 passive_gc_count; 782 u32 oldest_dirty_gc_count; 783 u32 n_gc_blocks; 784 u32 bg_gcs; 785 u32 n_retried_writes; 786 u32 n_retired_blocks; 787 u32 n_ecc_fixed; 788 u32 n_ecc_unfixed; 789 u32 n_tags_ecc_fixed; 790 u32 n_tags_ecc_unfixed; 791 u32 n_deletions; 792 u32 n_unmarked_deletions; 793 u32 refresh_count; 794 u32 cache_hits; 795 u32 tags_used; 796 u32 summary_used; 797 798 }; 799 800 /* The CheckpointDevice structure holds the device information that changes 801 *at runtime and must be preserved over unmount/mount cycles. 802 */ 803 struct yaffs_checkpt_dev { 804 int struct_type; 805 int n_erased_blocks; 806 int alloc_block; /* Current block being allocated off */ 807 u32 alloc_page; 808 int n_free_chunks; 809 810 int n_deleted_files; /* Count of files awaiting deletion; */ 811 int n_unlinked_files; /* Count of unlinked files. */ 812 int n_bg_deletions; /* Count of background deletions. */ 813 814 /* yaffs2 runtime stuff */ 815 unsigned seq_number; /* Sequence number of currently 816 * allocating block */ 817 818 }; 819 820 struct yaffs_checkpt_validity { 821 int struct_type; 822 u32 magic; 823 u32 version; 824 u32 head; 825 }; 826 827 struct yaffs_shadow_fixer { 828 int obj_id; 829 int shadowed_id; 830 struct yaffs_shadow_fixer *next; 831 }; 832 833 /* Structure for doing xattr modifications */ 834 struct yaffs_xattr_mod { 835 int set; /* If 0 then this is a deletion */ 836 const YCHAR *name; 837 const void *data; 838 int size; 839 int flags; 840 int result; 841 }; 842 843 /*----------------------- YAFFS Functions -----------------------*/ 844 845 int yaffs_guts_initialise(struct yaffs_dev *dev); 846 void yaffs_deinitialise(struct yaffs_dev *dev); 847 848 int yaffs_get_n_free_chunks(struct yaffs_dev *dev); 849 850 int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, 851 struct yaffs_obj *new_dir, const YCHAR * new_name); 852 853 int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name); 854 int yaffs_del_obj(struct yaffs_obj *obj); 855 856 int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size); 857 loff_t yaffs_get_obj_length(struct yaffs_obj *obj); 858 int yaffs_get_obj_inode(struct yaffs_obj *obj); 859 unsigned yaffs_get_obj_type(struct yaffs_obj *obj); 860 int yaffs_get_obj_link_count(struct yaffs_obj *obj); 861 862 /* File operations */ 863 int yaffs_file_rd(struct yaffs_obj *obj, u8 * buffer, loff_t offset, 864 int n_bytes); 865 int yaffs_wr_file(struct yaffs_obj *obj, const u8 * buffer, loff_t offset, 866 int n_bytes, int write_trhrough); 867 int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size); 868 869 struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, 870 const YCHAR *name, u32 mode, u32 uid, 871 u32 gid); 872 873 int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync); 874 875 /* Flushing and checkpointing */ 876 void yaffs_flush_whole_cache(struct yaffs_dev *dev); 877 878 int yaffs_checkpoint_save(struct yaffs_dev *dev); 879 int yaffs_checkpoint_restore(struct yaffs_dev *dev); 880 881 /* Directory operations */ 882 struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name, 883 u32 mode, u32 uid, u32 gid); 884 struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, 885 const YCHAR *name); 886 struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number); 887 888 /* Link operations */ 889 struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name, 890 struct yaffs_obj *equiv_obj); 891 892 struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj); 893 894 /* Symlink operations */ 895 struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, 896 const YCHAR *name, u32 mode, u32 uid, 897 u32 gid, const YCHAR *alias); 898 YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj); 899 900 /* Special inodes (fifos, sockets and devices) */ 901 struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, 902 const YCHAR *name, u32 mode, u32 uid, 903 u32 gid, u32 rdev); 904 905 int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, 906 const void *value, int size, int flags); 907 int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, 908 int size); 909 int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size); 910 int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name); 911 912 /* Special directories */ 913 struct yaffs_obj *yaffs_root(struct yaffs_dev *dev); 914 struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev); 915 916 void yaffs_handle_defered_free(struct yaffs_obj *obj); 917 918 void yaffs_update_dirty_dirs(struct yaffs_dev *dev); 919 920 int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency); 921 922 /* Debug dump */ 923 int yaffs_dump_obj(struct yaffs_obj *obj); 924 925 void yaffs_guts_test(struct yaffs_dev *dev); 926 927 /* A few useful functions to be used within the core files*/ 928 void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, 929 int lyn); 930 int yaffs_check_ff(u8 *buffer, int n_bytes); 931 void yaffs_handle_chunk_error(struct yaffs_dev *dev, 932 struct yaffs_block_info *bi); 933 934 u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev); 935 void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer); 936 937 struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, 938 int number, 939 enum yaffs_obj_type type); 940 int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, 941 int nand_chunk, int in_scan); 942 void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name); 943 void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, 944 const struct yaffs_obj_hdr *oh); 945 void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj); 946 YCHAR *yaffs_clone_str(const YCHAR *str); 947 void yaffs_link_fixup(struct yaffs_dev *dev, struct list_head *hard_list); 948 void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no); 949 int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, 950 int force, int is_shrink, int shadows, 951 struct yaffs_xattr_mod *xop); 952 void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, 953 int backward_scanning); 954 int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks); 955 struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev); 956 struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, 957 struct yaffs_file_var *file_struct, 958 u32 chunk_id, 959 struct yaffs_tnode *passed_tn); 960 961 int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, 962 int n_bytes, int write_trhrough); 963 void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size); 964 void yaffs_skip_rest_of_block(struct yaffs_dev *dev); 965 966 int yaffs_count_free_chunks(struct yaffs_dev *dev); 967 968 struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, 969 struct yaffs_file_var *file_struct, 970 u32 chunk_id); 971 972 u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, 973 unsigned pos); 974 975 int yaffs_is_non_empty_dir(struct yaffs_obj *obj); 976 977 int yaffs_format_dev(struct yaffs_dev *dev); 978 979 void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, 980 int *chunk_out, u32 *offset_out); 981 /* 982 * Marshalling functions to get loff_t file sizes into aand out of 983 * object headers. 984 */ 985 void yaffs_oh_size_load(struct yaffs_obj_hdr *oh, loff_t fsize); 986 loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh); 987 loff_t yaffs_max_file_size(struct yaffs_dev *dev); 988 989 990 #endif 991