1 /* 2 ------------------------------------------------------------------------- 3 * Filename: jffs2.c 4 * Version: $Id: jffs2_1pass.c,v 1.7 2002/01/25 01:56:47 nyet Exp $ 5 * Copyright: Copyright (C) 2001, Russ Dill 6 * Author: Russ Dill <Russ.Dill@asu.edu> 7 * Description: Module to load kernel from jffs2 8 *-----------------------------------------------------------------------*/ 9 /* 10 * some portions of this code are taken from jffs2, and as such, the 11 * following copyright notice is included. 12 * 13 * JFFS2 -- Journalling Flash File System, Version 2. 14 * 15 * Copyright (C) 2001 Red Hat, Inc. 16 * 17 * Created by David Woodhouse <dwmw2@cambridge.redhat.com> 18 * 19 * The original JFFS, from which the design for JFFS2 was derived, 20 * was designed and implemented by Axis Communications AB. 21 * 22 * The contents of this file are subject to the Red Hat eCos Public 23 * License Version 1.1 (the "Licence"); you may not use this file 24 * except in compliance with the Licence. You may obtain a copy of 25 * the Licence at http://www.redhat.com/ 26 * 27 * Software distributed under the Licence is distributed on an "AS IS" 28 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. 29 * See the Licence for the specific language governing rights and 30 * limitations under the Licence. 31 * 32 * The Original Code is JFFS2 - Journalling Flash File System, version 2 33 * 34 * Alternatively, the contents of this file may be used under the 35 * terms of the GNU General Public License version 2 (the "GPL"), in 36 * which case the provisions of the GPL are applicable instead of the 37 * above. If you wish to allow the use of your version of this file 38 * only under the terms of the GPL and not to allow others to use your 39 * version of this file under the RHEPL, indicate your decision by 40 * deleting the provisions above and replace them with the notice and 41 * other provisions required by the GPL. If you do not delete the 42 * provisions above, a recipient may use your version of this file 43 * under either the RHEPL or the GPL. 44 * 45 * $Id: jffs2_1pass.c,v 1.7 2002/01/25 01:56:47 nyet Exp $ 46 * 47 */ 48 49 /* Ok, so anyone who knows the jffs2 code will probably want to get a papar 50 * bag to throw up into before reading this code. I looked through the jffs2 51 * code, the caching scheme is very elegant. I tried to keep the version 52 * for a bootloader as small and simple as possible. Instead of worring about 53 * unneccesary data copies, node scans, etc, I just optimized for the known 54 * common case, a kernel, which looks like: 55 * (1) most pages are 4096 bytes 56 * (2) version numbers are somewhat sorted in acsending order 57 * (3) multiple compressed blocks making up one page is uncommon 58 * 59 * So I create a linked list of decending version numbers (insertions at the 60 * head), and then for each page, walk down the list, until a matching page 61 * with 4096 bytes is found, and then decompress the watching pages in 62 * reverse order. 63 * 64 */ 65 66 /* 67 * Adapted by Nye Liu <nyet@zumanetworks.com> and 68 * Rex Feany <rfeany@zumanetworks.com> 69 * on Jan/2002 for U-Boot. 70 * 71 * Clipped out all the non-1pass functions, cleaned up warnings, 72 * wrappers, etc. No major changes to the code. 73 * Please, he really means it when he said have a paper bag 74 * handy. We needed it ;). 75 * 76 */ 77 78 /* 79 * Bugfixing by Kai-Uwe Bloem <kai-uwe.bloem@auerswald.de>, (C) Mar/2003 80 * 81 * - overhaul of the memory management. Removed much of the "paper-bagging" 82 * in that part of the code, fixed several bugs, now frees memory when 83 * partition is changed. 84 * It's still ugly :-( 85 * - fixed a bug in jffs2_1pass_read_inode where the file length calculation 86 * was incorrect. Removed a bit of the paper-bagging as well. 87 * - removed double crc calculation for fragment headers in jffs2_private.h 88 * for speedup. 89 * - scan_empty rewritten in a more "standard" manner (non-paperbag, that is). 90 * - spinning wheel now spins depending on how much memory has been scanned 91 * - lots of small changes all over the place to "improve" readability. 92 * - implemented fragment sorting to ensure that the newest data is copied 93 * if there are multiple copies of fragments for a certain file offset. 94 * 95 * The fragment sorting feature must be enabled by CFG_JFFS2_SORT_FRAGMENTS. 96 * Sorting is done while adding fragments to the lists, which is more or less a 97 * bubble sort. This takes a lot of time, and is most probably not an issue if 98 * the boot filesystem is always mounted readonly. 99 * 100 * You should define it if the boot filesystem is mounted writable, and updates 101 * to the boot files are done by copying files to that filesystem. 102 * 103 * 104 * There's a big issue left: endianess is completely ignored in this code. Duh! 105 * 106 * 107 * You still should have paper bags at hand :-(. The code lacks more or less 108 * any comment, and is still arcane and difficult to read in places. As this 109 * might be incompatible with any new code from the jffs2 maintainers anyway, 110 * it should probably be dumped and replaced by something like jffs2reader! 111 */ 112 113 114 #include <common.h> 115 #include <config.h> 116 #include <malloc.h> 117 #include <linux/stat.h> 118 #include <linux/time.h> 119 #include <watchdog.h> 120 #include <jffs2/jffs2.h> 121 #include <jffs2/jffs2_1pass.h> 122 123 #include "jffs2_private.h" 124 125 126 #define NODE_CHUNK 1024 /* size of memory allocation chunk in b_nodes */ 127 #define SPIN_BLKSIZE 18 /* spin after having scanned 1<<BLKSIZE bytes */ 128 129 /* Debugging switches */ 130 #undef DEBUG_DIRENTS /* print directory entry list after scan */ 131 #undef DEBUG_FRAGMENTS /* print fragment list after scan */ 132 #undef DEBUG /* enable debugging messages */ 133 134 135 #ifdef DEBUG 136 # define DEBUGF(fmt,args...) printf(fmt ,##args) 137 #else 138 # define DEBUGF(fmt,args...) 139 #endif 140 141 /* keeps pointer to currentlu processed partition */ 142 static struct part_info *current_part; 143 144 #if (defined(CONFIG_JFFS2_NAND) && \ 145 defined(CONFIG_CMD_NAND) ) 146 #if defined(CONFIG_NAND_LEGACY) 147 #include <linux/mtd/nand_legacy.h> 148 #else 149 #include <nand.h> 150 #endif 151 /* 152 * Support for jffs2 on top of NAND-flash 153 * 154 * NAND memory isn't mapped in processor's address space, 155 * so data should be fetched from flash before 156 * being processed. This is exactly what functions declared 157 * here do. 158 * 159 */ 160 161 #if defined(CONFIG_NAND_LEGACY) 162 /* this one defined in nand_legacy.c */ 163 int read_jffs2_nand(size_t start, size_t len, 164 size_t * retlen, u_char * buf, int nanddev); 165 #endif 166 167 #define NAND_PAGE_SIZE 512 168 #define NAND_PAGE_SHIFT 9 169 #define NAND_PAGE_MASK (~(NAND_PAGE_SIZE-1)) 170 171 #ifndef NAND_CACHE_PAGES 172 #define NAND_CACHE_PAGES 16 173 #endif 174 #define NAND_CACHE_SIZE (NAND_CACHE_PAGES*NAND_PAGE_SIZE) 175 176 static u8* nand_cache = NULL; 177 static u32 nand_cache_off = (u32)-1; 178 179 static int read_nand_cached(u32 off, u32 size, u_char *buf) 180 { 181 struct mtdids *id = current_part->dev->id; 182 u32 bytes_read = 0; 183 size_t retlen; 184 int cpy_bytes; 185 186 while (bytes_read < size) { 187 if ((off + bytes_read < nand_cache_off) || 188 (off + bytes_read >= nand_cache_off+NAND_CACHE_SIZE)) { 189 nand_cache_off = (off + bytes_read) & NAND_PAGE_MASK; 190 if (!nand_cache) { 191 /* This memory never gets freed but 'cause 192 it's a bootloader, nobody cares */ 193 nand_cache = malloc(NAND_CACHE_SIZE); 194 if (!nand_cache) { 195 printf("read_nand_cached: can't alloc cache size %d bytes\n", 196 NAND_CACHE_SIZE); 197 return -1; 198 } 199 } 200 201 #if defined(CONFIG_NAND_LEGACY) 202 if (read_jffs2_nand(nand_cache_off, NAND_CACHE_SIZE, 203 &retlen, nand_cache, id->num) < 0 || 204 retlen != NAND_CACHE_SIZE) { 205 printf("read_nand_cached: error reading nand off %#x size %d bytes\n", 206 nand_cache_off, NAND_CACHE_SIZE); 207 return -1; 208 } 209 #else 210 retlen = NAND_CACHE_SIZE; 211 if (nand_read(&nand_info[id->num], nand_cache_off, 212 &retlen, nand_cache) != 0 || 213 retlen != NAND_CACHE_SIZE) { 214 printf("read_nand_cached: error reading nand off %#x size %d bytes\n", 215 nand_cache_off, NAND_CACHE_SIZE); 216 return -1; 217 } 218 #endif 219 } 220 cpy_bytes = nand_cache_off + NAND_CACHE_SIZE - (off + bytes_read); 221 if (cpy_bytes > size - bytes_read) 222 cpy_bytes = size - bytes_read; 223 memcpy(buf + bytes_read, 224 nand_cache + off + bytes_read - nand_cache_off, 225 cpy_bytes); 226 bytes_read += cpy_bytes; 227 } 228 return bytes_read; 229 } 230 231 static void *get_fl_mem_nand(u32 off, u32 size, void *ext_buf) 232 { 233 u_char *buf = ext_buf ? (u_char*)ext_buf : (u_char*)malloc(size); 234 235 if (NULL == buf) { 236 printf("get_fl_mem_nand: can't alloc %d bytes\n", size); 237 return NULL; 238 } 239 if (read_nand_cached(off, size, buf) < 0) { 240 if (!ext_buf) 241 free(buf); 242 return NULL; 243 } 244 245 return buf; 246 } 247 248 static void *get_node_mem_nand(u32 off) 249 { 250 struct jffs2_unknown_node node; 251 void *ret = NULL; 252 253 if (NULL == get_fl_mem_nand(off, sizeof(node), &node)) 254 return NULL; 255 256 if (!(ret = get_fl_mem_nand(off, node.magic == 257 JFFS2_MAGIC_BITMASK ? node.totlen : sizeof(node), 258 NULL))) { 259 printf("off = %#x magic %#x type %#x node.totlen = %d\n", 260 off, node.magic, node.nodetype, node.totlen); 261 } 262 return ret; 263 } 264 265 static void put_fl_mem_nand(void *buf) 266 { 267 free(buf); 268 } 269 #endif 270 271 #if defined(CONFIG_CMD_ONENAND) 272 273 #include <linux/mtd/mtd.h> 274 #include <linux/mtd/onenand.h> 275 #include <onenand_uboot.h> 276 277 #define ONENAND_PAGE_SIZE 2048 278 #define ONENAND_PAGE_SHIFT 11 279 #define ONENAND_PAGE_MASK (~(ONENAND_PAGE_SIZE-1)) 280 281 #ifndef ONENAND_CACHE_PAGES 282 #define ONENAND_CACHE_PAGES 4 283 #endif 284 #define ONENAND_CACHE_SIZE (ONENAND_CACHE_PAGES*ONENAND_PAGE_SIZE) 285 286 static u8* onenand_cache; 287 static u32 onenand_cache_off = (u32)-1; 288 289 static int read_onenand_cached(u32 off, u32 size, u_char *buf) 290 { 291 u32 bytes_read = 0; 292 size_t retlen; 293 int cpy_bytes; 294 295 while (bytes_read < size) { 296 if ((off + bytes_read < onenand_cache_off) || 297 (off + bytes_read >= onenand_cache_off + ONENAND_CACHE_SIZE)) { 298 onenand_cache_off = (off + bytes_read) & ONENAND_PAGE_MASK; 299 if (!onenand_cache) { 300 /* This memory never gets freed but 'cause 301 it's a bootloader, nobody cares */ 302 onenand_cache = malloc(ONENAND_CACHE_SIZE); 303 if (!onenand_cache) { 304 printf("read_onenand_cached: can't alloc cache size %d bytes\n", 305 ONENAND_CACHE_SIZE); 306 return -1; 307 } 308 } 309 310 retlen = ONENAND_CACHE_SIZE; 311 if (onenand_read(&onenand_mtd, onenand_cache_off, retlen, 312 &retlen, onenand_cache) != 0 || 313 retlen != ONENAND_CACHE_SIZE) { 314 printf("read_onenand_cached: error reading nand off %#x size %d bytes\n", 315 onenand_cache_off, ONENAND_CACHE_SIZE); 316 return -1; 317 } 318 } 319 cpy_bytes = onenand_cache_off + ONENAND_CACHE_SIZE - (off + bytes_read); 320 if (cpy_bytes > size - bytes_read) 321 cpy_bytes = size - bytes_read; 322 memcpy(buf + bytes_read, 323 onenand_cache + off + bytes_read - onenand_cache_off, 324 cpy_bytes); 325 bytes_read += cpy_bytes; 326 } 327 return bytes_read; 328 } 329 330 static void *get_fl_mem_onenand(u32 off, u32 size, void *ext_buf) 331 { 332 u_char *buf = ext_buf ? (u_char *)ext_buf : (u_char *)malloc(size); 333 334 if (NULL == buf) { 335 printf("get_fl_mem_onenand: can't alloc %d bytes\n", size); 336 return NULL; 337 } 338 if (read_onenand_cached(off, size, buf) < 0) { 339 if (!ext_buf) 340 free(buf); 341 return NULL; 342 } 343 344 return buf; 345 } 346 347 static void *get_node_mem_onenand(u32 off) 348 { 349 struct jffs2_unknown_node node; 350 void *ret = NULL; 351 352 if (NULL == get_fl_mem_onenand(off, sizeof(node), &node)) 353 return NULL; 354 355 ret = get_fl_mem_onenand(off, node.magic == 356 JFFS2_MAGIC_BITMASK ? node.totlen : sizeof(node), 357 NULL); 358 if (!ret) { 359 printf("off = %#x magic %#x type %#x node.totlen = %d\n", 360 off, node.magic, node.nodetype, node.totlen); 361 } 362 return ret; 363 } 364 365 366 static void put_fl_mem_onenand(void *buf) 367 { 368 free(buf); 369 } 370 #endif 371 372 373 #if defined(CONFIG_CMD_FLASH) 374 /* 375 * Support for jffs2 on top of NOR-flash 376 * 377 * NOR flash memory is mapped in processor's address space, 378 * just return address. 379 */ 380 static inline void *get_fl_mem_nor(u32 off) 381 { 382 u32 addr = off; 383 struct mtdids *id = current_part->dev->id; 384 385 extern flash_info_t flash_info[]; 386 flash_info_t *flash = &flash_info[id->num]; 387 388 addr += flash->start[0]; 389 return (void*)addr; 390 } 391 392 static inline void *get_node_mem_nor(u32 off) 393 { 394 return (void*)get_fl_mem_nor(off); 395 } 396 #endif 397 398 399 /* 400 * Generic jffs2 raw memory and node read routines. 401 * 402 */ 403 static inline void *get_fl_mem(u32 off, u32 size, void *ext_buf) 404 { 405 struct mtdids *id = current_part->dev->id; 406 407 #if defined(CONFIG_CMD_FLASH) 408 if (id->type == MTD_DEV_TYPE_NOR) 409 return get_fl_mem_nor(off); 410 #endif 411 412 #if defined(CONFIG_JFFS2_NAND) && defined(CONFIG_CMD_NAND) 413 if (id->type == MTD_DEV_TYPE_NAND) 414 return get_fl_mem_nand(off, size, ext_buf); 415 #endif 416 417 #if defined(CONFIG_CMD_ONENAND) 418 if (id->type == MTD_DEV_TYPE_ONENAND) 419 return get_fl_mem_onenand(off, size, ext_buf); 420 #endif 421 422 printf("get_fl_mem: unknown device type, using raw offset!\n"); 423 return (void*)off; 424 } 425 426 static inline void *get_node_mem(u32 off) 427 { 428 struct mtdids *id = current_part->dev->id; 429 430 #if defined(CONFIG_CMD_FLASH) 431 if (id->type == MTD_DEV_TYPE_NOR) 432 return get_node_mem_nor(off); 433 #endif 434 435 #if defined(CONFIG_JFFS2_NAND) && \ 436 defined(CONFIG_CMD_NAND) 437 if (id->type == MTD_DEV_TYPE_NAND) 438 return get_node_mem_nand(off); 439 #endif 440 441 #if defined(CONFIG_CMD_ONENAND) 442 if (id->type == MTD_DEV_TYPE_ONENAND) 443 return get_node_mem_onenand(off); 444 #endif 445 446 printf("get_node_mem: unknown device type, using raw offset!\n"); 447 return (void*)off; 448 } 449 450 static inline void put_fl_mem(void *buf) 451 { 452 #if defined(CONFIG_JFFS2_NAND) && \ 453 defined(CONFIG_CMD_NAND) 454 struct mtdids *id = current_part->dev->id; 455 456 if (id->type == MTD_DEV_TYPE_NAND) 457 return put_fl_mem_nand(buf); 458 #endif 459 460 #if defined(CONFIG_CMD_ONENAND) 461 struct mtdids *id = current_part->dev->id; 462 463 if (id->type == MTD_DEV_TYPE_ONENAND) 464 return put_fl_mem_onenand(buf); 465 #endif 466 } 467 468 /* Compression names */ 469 static char *compr_names[] = { 470 "NONE", 471 "ZERO", 472 "RTIME", 473 "RUBINMIPS", 474 "COPY", 475 "DYNRUBIN", 476 "ZLIB", 477 #if defined(CONFIG_JFFS2_LZO_LZARI) 478 "LZO", 479 "LZARI", 480 #endif 481 }; 482 483 /* Spinning wheel */ 484 static char spinner[] = { '|', '/', '-', '\\' }; 485 486 /* Memory management */ 487 struct mem_block { 488 u32 index; 489 struct mem_block *next; 490 struct b_node nodes[NODE_CHUNK]; 491 }; 492 493 494 static void 495 free_nodes(struct b_list *list) 496 { 497 while (list->listMemBase != NULL) { 498 struct mem_block *next = list->listMemBase->next; 499 free( list->listMemBase ); 500 list->listMemBase = next; 501 } 502 } 503 504 static struct b_node * 505 add_node(struct b_list *list) 506 { 507 u32 index = 0; 508 struct mem_block *memBase; 509 struct b_node *b; 510 511 memBase = list->listMemBase; 512 if (memBase != NULL) 513 index = memBase->index; 514 #if 0 515 putLabeledWord("add_node: index = ", index); 516 putLabeledWord("add_node: memBase = ", list->listMemBase); 517 #endif 518 519 if (memBase == NULL || index >= NODE_CHUNK) { 520 /* we need more space before we continue */ 521 memBase = mmalloc(sizeof(struct mem_block)); 522 if (memBase == NULL) { 523 putstr("add_node: malloc failed\n"); 524 return NULL; 525 } 526 memBase->next = list->listMemBase; 527 index = 0; 528 #if 0 529 putLabeledWord("add_node: alloced a new membase at ", *memBase); 530 #endif 531 532 } 533 /* now we have room to add it. */ 534 b = &memBase->nodes[index]; 535 index ++; 536 537 memBase->index = index; 538 list->listMemBase = memBase; 539 list->listCount++; 540 return b; 541 } 542 543 static struct b_node * 544 insert_node(struct b_list *list, u32 offset) 545 { 546 struct b_node *new; 547 #ifdef CFG_JFFS2_SORT_FRAGMENTS 548 struct b_node *b, *prev; 549 #endif 550 551 if (!(new = add_node(list))) { 552 putstr("add_node failed!\r\n"); 553 return NULL; 554 } 555 new->offset = offset; 556 557 #ifdef CFG_JFFS2_SORT_FRAGMENTS 558 if (list->listTail != NULL && list->listCompare(new, list->listTail)) 559 prev = list->listTail; 560 else if (list->listLast != NULL && list->listCompare(new, list->listLast)) 561 prev = list->listLast; 562 else 563 prev = NULL; 564 565 for (b = (prev ? prev->next : list->listHead); 566 b != NULL && list->listCompare(new, b); 567 prev = b, b = b->next) { 568 list->listLoops++; 569 } 570 if (b != NULL) 571 list->listLast = prev; 572 573 if (b != NULL) { 574 new->next = b; 575 if (prev != NULL) 576 prev->next = new; 577 else 578 list->listHead = new; 579 } else 580 #endif 581 { 582 new->next = (struct b_node *) NULL; 583 if (list->listTail != NULL) { 584 list->listTail->next = new; 585 list->listTail = new; 586 } else { 587 list->listTail = list->listHead = new; 588 } 589 } 590 591 return new; 592 } 593 594 #ifdef CFG_JFFS2_SORT_FRAGMENTS 595 /* Sort data entries with the latest version last, so that if there 596 * is overlapping data the latest version will be used. 597 */ 598 static int compare_inodes(struct b_node *new, struct b_node *old) 599 { 600 struct jffs2_raw_inode ojNew; 601 struct jffs2_raw_inode ojOld; 602 struct jffs2_raw_inode *jNew = 603 (struct jffs2_raw_inode *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew); 604 struct jffs2_raw_inode *jOld = 605 (struct jffs2_raw_inode *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld); 606 607 return jNew->version > jOld->version; 608 } 609 610 /* Sort directory entries so all entries in the same directory 611 * with the same name are grouped together, with the latest version 612 * last. This makes it easy to eliminate all but the latest version 613 * by marking the previous version dead by setting the inode to 0. 614 */ 615 static int compare_dirents(struct b_node *new, struct b_node *old) 616 { 617 struct jffs2_raw_dirent ojNew; 618 struct jffs2_raw_dirent ojOld; 619 struct jffs2_raw_dirent *jNew = 620 (struct jffs2_raw_dirent *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew); 621 struct jffs2_raw_dirent *jOld = 622 (struct jffs2_raw_dirent *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld); 623 int cmp; 624 625 /* ascending sort by pino */ 626 if (jNew->pino != jOld->pino) 627 return jNew->pino > jOld->pino; 628 629 /* pino is the same, so use ascending sort by nsize, so 630 * we don't do strncmp unless we really must. 631 */ 632 if (jNew->nsize != jOld->nsize) 633 return jNew->nsize > jOld->nsize; 634 635 /* length is also the same, so use ascending sort by name 636 */ 637 cmp = strncmp((char *)jNew->name, (char *)jOld->name, jNew->nsize); 638 if (cmp != 0) 639 return cmp > 0; 640 641 /* we have duplicate names in this directory, so use ascending 642 * sort by version 643 */ 644 if (jNew->version > jOld->version) { 645 /* since jNew is newer, we know jOld is not valid, so 646 * mark it with inode 0 and it will not be used 647 */ 648 jOld->ino = 0; 649 return 1; 650 } 651 652 return 0; 653 } 654 #endif 655 656 static u32 657 jffs2_scan_empty(u32 start_offset, struct part_info *part) 658 { 659 char *max = (char *)(part->offset + part->size - sizeof(struct jffs2_raw_inode)); 660 char *offset = (char *)(part->offset + start_offset); 661 u32 off; 662 663 while (offset < max && 664 *(u32*)get_fl_mem((u32)offset, sizeof(u32), &off) == 0xFFFFFFFF) { 665 offset += sizeof(u32); 666 /* return if spinning is due */ 667 if (((u32)offset & ((1 << SPIN_BLKSIZE)-1)) == 0) break; 668 } 669 670 return (u32)offset - part->offset; 671 } 672 673 void 674 jffs2_free_cache(struct part_info *part) 675 { 676 struct b_lists *pL; 677 678 if (part->jffs2_priv != NULL) { 679 pL = (struct b_lists *)part->jffs2_priv; 680 free_nodes(&pL->frag); 681 free_nodes(&pL->dir); 682 free(pL); 683 } 684 } 685 686 static u32 687 jffs_init_1pass_list(struct part_info *part) 688 { 689 struct b_lists *pL; 690 691 jffs2_free_cache(part); 692 693 if (NULL != (part->jffs2_priv = malloc(sizeof(struct b_lists)))) { 694 pL = (struct b_lists *)part->jffs2_priv; 695 696 memset(pL, 0, sizeof(*pL)); 697 #ifdef CFG_JFFS2_SORT_FRAGMENTS 698 pL->dir.listCompare = compare_dirents; 699 pL->frag.listCompare = compare_inodes; 700 #endif 701 } 702 return 0; 703 } 704 705 /* find the inode from the slashless name given a parent */ 706 static long 707 jffs2_1pass_read_inode(struct b_lists *pL, u32 inode, char *dest) 708 { 709 struct b_node *b; 710 struct jffs2_raw_inode *jNode; 711 u32 totalSize = 0; 712 u32 latestVersion = 0; 713 uchar *lDest; 714 uchar *src; 715 long ret; 716 int i; 717 u32 counter = 0; 718 #ifdef CFG_JFFS2_SORT_FRAGMENTS 719 /* Find file size before loading any data, so fragments that 720 * start past the end of file can be ignored. A fragment 721 * that is partially in the file is loaded, so extra data may 722 * be loaded up to the next 4K boundary above the file size. 723 * This shouldn't cause trouble when loading kernel images, so 724 * we will live with it. 725 */ 726 for (b = pL->frag.listHead; b != NULL; b = b->next) { 727 jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 728 sizeof(struct jffs2_raw_inode), NULL); 729 if ((inode == jNode->ino)) { 730 /* get actual file length from the newest node */ 731 if (jNode->version >= latestVersion) { 732 totalSize = jNode->isize; 733 latestVersion = jNode->version; 734 } 735 } 736 put_fl_mem(jNode); 737 } 738 #endif 739 740 for (b = pL->frag.listHead; b != NULL; b = b->next) { 741 jNode = (struct jffs2_raw_inode *) get_node_mem(b->offset); 742 if ((inode == jNode->ino)) { 743 #if 0 744 putLabeledWord("\r\n\r\nread_inode: totlen = ", jNode->totlen); 745 putLabeledWord("read_inode: inode = ", jNode->ino); 746 putLabeledWord("read_inode: version = ", jNode->version); 747 putLabeledWord("read_inode: isize = ", jNode->isize); 748 putLabeledWord("read_inode: offset = ", jNode->offset); 749 putLabeledWord("read_inode: csize = ", jNode->csize); 750 putLabeledWord("read_inode: dsize = ", jNode->dsize); 751 putLabeledWord("read_inode: compr = ", jNode->compr); 752 putLabeledWord("read_inode: usercompr = ", jNode->usercompr); 753 putLabeledWord("read_inode: flags = ", jNode->flags); 754 #endif 755 756 #ifndef CFG_JFFS2_SORT_FRAGMENTS 757 /* get actual file length from the newest node */ 758 if (jNode->version >= latestVersion) { 759 totalSize = jNode->isize; 760 latestVersion = jNode->version; 761 } 762 #endif 763 764 if(dest) { 765 src = ((uchar *) jNode) + sizeof(struct jffs2_raw_inode); 766 /* ignore data behind latest known EOF */ 767 if (jNode->offset > totalSize) { 768 put_fl_mem(jNode); 769 continue; 770 } 771 772 lDest = (uchar *) (dest + jNode->offset); 773 #if 0 774 putLabeledWord("read_inode: src = ", src); 775 putLabeledWord("read_inode: dest = ", lDest); 776 #endif 777 switch (jNode->compr) { 778 case JFFS2_COMPR_NONE: 779 ret = (unsigned long) ldr_memcpy(lDest, src, jNode->dsize); 780 break; 781 case JFFS2_COMPR_ZERO: 782 ret = 0; 783 for (i = 0; i < jNode->dsize; i++) 784 *(lDest++) = 0; 785 break; 786 case JFFS2_COMPR_RTIME: 787 ret = 0; 788 rtime_decompress(src, lDest, jNode->csize, jNode->dsize); 789 break; 790 case JFFS2_COMPR_DYNRUBIN: 791 /* this is slow but it works */ 792 ret = 0; 793 dynrubin_decompress(src, lDest, jNode->csize, jNode->dsize); 794 break; 795 case JFFS2_COMPR_ZLIB: 796 ret = zlib_decompress(src, lDest, jNode->csize, jNode->dsize); 797 break; 798 #if defined(CONFIG_JFFS2_LZO_LZARI) 799 case JFFS2_COMPR_LZO: 800 ret = lzo_decompress(src, lDest, jNode->csize, jNode->dsize); 801 break; 802 case JFFS2_COMPR_LZARI: 803 ret = lzari_decompress(src, lDest, jNode->csize, jNode->dsize); 804 break; 805 #endif 806 default: 807 /* unknown */ 808 putLabeledWord("UNKOWN COMPRESSION METHOD = ", jNode->compr); 809 put_fl_mem(jNode); 810 return -1; 811 break; 812 } 813 } 814 815 #if 0 816 putLabeledWord("read_inode: totalSize = ", totalSize); 817 putLabeledWord("read_inode: compr ret = ", ret); 818 #endif 819 } 820 counter++; 821 put_fl_mem(jNode); 822 } 823 824 #if 0 825 putLabeledWord("read_inode: returning = ", totalSize); 826 #endif 827 return totalSize; 828 } 829 830 /* find the inode from the slashless name given a parent */ 831 static u32 832 jffs2_1pass_find_inode(struct b_lists * pL, const char *name, u32 pino) 833 { 834 struct b_node *b; 835 struct jffs2_raw_dirent *jDir; 836 int len; 837 u32 counter; 838 u32 version = 0; 839 u32 inode = 0; 840 841 /* name is assumed slash free */ 842 len = strlen(name); 843 844 counter = 0; 845 /* we need to search all and return the inode with the highest version */ 846 for(b = pL->dir.listHead; b; b = b->next, counter++) { 847 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 848 if ((pino == jDir->pino) && (len == jDir->nsize) && 849 (jDir->ino) && /* 0 for unlink */ 850 (!strncmp((char *)jDir->name, name, len))) { /* a match */ 851 if (jDir->version < version) { 852 put_fl_mem(jDir); 853 continue; 854 } 855 856 if (jDir->version == version && inode != 0) { 857 /* I'm pretty sure this isn't legal */ 858 putstr(" ** ERROR ** "); 859 putnstr(jDir->name, jDir->nsize); 860 putLabeledWord(" has dup version =", version); 861 } 862 inode = jDir->ino; 863 version = jDir->version; 864 } 865 #if 0 866 putstr("\r\nfind_inode:p&l ->"); 867 putnstr(jDir->name, jDir->nsize); 868 putstr("\r\n"); 869 putLabeledWord("pino = ", jDir->pino); 870 putLabeledWord("nsize = ", jDir->nsize); 871 putLabeledWord("b = ", (u32) b); 872 putLabeledWord("counter = ", counter); 873 #endif 874 put_fl_mem(jDir); 875 } 876 return inode; 877 } 878 879 char *mkmodestr(unsigned long mode, char *str) 880 { 881 static const char *l = "xwr"; 882 int mask = 1, i; 883 char c; 884 885 switch (mode & S_IFMT) { 886 case S_IFDIR: str[0] = 'd'; break; 887 case S_IFBLK: str[0] = 'b'; break; 888 case S_IFCHR: str[0] = 'c'; break; 889 case S_IFIFO: str[0] = 'f'; break; 890 case S_IFLNK: str[0] = 'l'; break; 891 case S_IFSOCK: str[0] = 's'; break; 892 case S_IFREG: str[0] = '-'; break; 893 default: str[0] = '?'; 894 } 895 896 for(i = 0; i < 9; i++) { 897 c = l[i%3]; 898 str[9-i] = (mode & mask)?c:'-'; 899 mask = mask<<1; 900 } 901 902 if(mode & S_ISUID) str[3] = (mode & S_IXUSR)?'s':'S'; 903 if(mode & S_ISGID) str[6] = (mode & S_IXGRP)?'s':'S'; 904 if(mode & S_ISVTX) str[9] = (mode & S_IXOTH)?'t':'T'; 905 str[10] = '\0'; 906 return str; 907 } 908 909 static inline void dump_stat(struct stat *st, const char *name) 910 { 911 char str[20]; 912 char s[64], *p; 913 914 if (st->st_mtime == (time_t)(-1)) /* some ctimes really hate -1 */ 915 st->st_mtime = 1; 916 917 ctime_r((time_t *)&st->st_mtime, s/*,64*/); /* newlib ctime doesn't have buflen */ 918 919 if ((p = strchr(s,'\n')) != NULL) *p = '\0'; 920 if ((p = strchr(s,'\r')) != NULL) *p = '\0'; 921 922 /* 923 printf("%6lo %s %8ld %s %s\n", st->st_mode, mkmodestr(st->st_mode, str), 924 st->st_size, s, name); 925 */ 926 927 printf(" %s %8ld %s %s", mkmodestr(st->st_mode,str), st->st_size, s, name); 928 } 929 930 static inline u32 dump_inode(struct b_lists * pL, struct jffs2_raw_dirent *d, struct jffs2_raw_inode *i) 931 { 932 char fname[256]; 933 struct stat st; 934 935 if(!d || !i) return -1; 936 937 strncpy(fname, (char *)d->name, d->nsize); 938 fname[d->nsize] = '\0'; 939 940 memset(&st,0,sizeof(st)); 941 942 st.st_mtime = i->mtime; 943 st.st_mode = i->mode; 944 st.st_ino = i->ino; 945 946 /* neither dsize nor isize help us.. do it the long way */ 947 st.st_size = jffs2_1pass_read_inode(pL, i->ino, NULL); 948 949 dump_stat(&st, fname); 950 951 if (d->type == DT_LNK) { 952 unsigned char *src = (unsigned char *) (&i[1]); 953 putstr(" -> "); 954 putnstr(src, (int)i->dsize); 955 } 956 957 putstr("\r\n"); 958 959 return 0; 960 } 961 962 /* list inodes with the given pino */ 963 static u32 964 jffs2_1pass_list_inodes(struct b_lists * pL, u32 pino) 965 { 966 struct b_node *b; 967 struct jffs2_raw_dirent *jDir; 968 969 for (b = pL->dir.listHead; b; b = b->next) { 970 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 971 if ((pino == jDir->pino) && (jDir->ino)) { /* ino=0 -> unlink */ 972 u32 i_version = 0; 973 struct jffs2_raw_inode ojNode; 974 struct jffs2_raw_inode *jNode, *i = NULL; 975 struct b_node *b2 = pL->frag.listHead; 976 977 while (b2) { 978 jNode = (struct jffs2_raw_inode *) 979 get_fl_mem(b2->offset, sizeof(ojNode), &ojNode); 980 if (jNode->ino == jDir->ino && jNode->version >= i_version) { 981 if (i) 982 put_fl_mem(i); 983 984 if (jDir->type == DT_LNK) 985 i = get_node_mem(b2->offset); 986 else 987 i = get_fl_mem(b2->offset, sizeof(*i), NULL); 988 } 989 b2 = b2->next; 990 } 991 992 dump_inode(pL, jDir, i); 993 put_fl_mem(i); 994 } 995 put_fl_mem(jDir); 996 } 997 return pino; 998 } 999 1000 static u32 1001 jffs2_1pass_search_inode(struct b_lists * pL, const char *fname, u32 pino) 1002 { 1003 int i; 1004 char tmp[256]; 1005 char working_tmp[256]; 1006 char *c; 1007 1008 /* discard any leading slash */ 1009 i = 0; 1010 while (fname[i] == '/') 1011 i++; 1012 strcpy(tmp, &fname[i]); 1013 1014 while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */ 1015 { 1016 strncpy(working_tmp, tmp, c - tmp); 1017 working_tmp[c - tmp] = '\0'; 1018 #if 0 1019 putstr("search_inode: tmp = "); 1020 putstr(tmp); 1021 putstr("\r\n"); 1022 putstr("search_inode: wtmp = "); 1023 putstr(working_tmp); 1024 putstr("\r\n"); 1025 putstr("search_inode: c = "); 1026 putstr(c); 1027 putstr("\r\n"); 1028 #endif 1029 for (i = 0; i < strlen(c) - 1; i++) 1030 tmp[i] = c[i + 1]; 1031 tmp[i] = '\0'; 1032 #if 0 1033 putstr("search_inode: post tmp = "); 1034 putstr(tmp); 1035 putstr("\r\n"); 1036 #endif 1037 1038 if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino))) { 1039 putstr("find_inode failed for name="); 1040 putstr(working_tmp); 1041 putstr("\r\n"); 1042 return 0; 1043 } 1044 } 1045 /* this is for the bare filename, directories have already been mapped */ 1046 if (!(pino = jffs2_1pass_find_inode(pL, tmp, pino))) { 1047 putstr("find_inode failed for name="); 1048 putstr(tmp); 1049 putstr("\r\n"); 1050 return 0; 1051 } 1052 return pino; 1053 1054 } 1055 1056 static u32 1057 jffs2_1pass_resolve_inode(struct b_lists * pL, u32 ino) 1058 { 1059 struct b_node *b; 1060 struct b_node *b2; 1061 struct jffs2_raw_dirent *jDir; 1062 struct jffs2_raw_inode *jNode; 1063 u8 jDirFoundType = 0; 1064 u32 jDirFoundIno = 0; 1065 u32 jDirFoundPino = 0; 1066 char tmp[256]; 1067 u32 version = 0; 1068 u32 pino; 1069 unsigned char *src; 1070 1071 /* we need to search all and return the inode with the highest version */ 1072 for(b = pL->dir.listHead; b; b = b->next) { 1073 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 1074 if (ino == jDir->ino) { 1075 if (jDir->version < version) { 1076 put_fl_mem(jDir); 1077 continue; 1078 } 1079 1080 if (jDir->version == version && jDirFoundType) { 1081 /* I'm pretty sure this isn't legal */ 1082 putstr(" ** ERROR ** "); 1083 putnstr(jDir->name, jDir->nsize); 1084 putLabeledWord(" has dup version (resolve) = ", 1085 version); 1086 } 1087 1088 jDirFoundType = jDir->type; 1089 jDirFoundIno = jDir->ino; 1090 jDirFoundPino = jDir->pino; 1091 version = jDir->version; 1092 } 1093 put_fl_mem(jDir); 1094 } 1095 /* now we found the right entry again. (shoulda returned inode*) */ 1096 if (jDirFoundType != DT_LNK) 1097 return jDirFoundIno; 1098 1099 /* it's a soft link so we follow it again. */ 1100 b2 = pL->frag.listHead; 1101 while (b2) { 1102 jNode = (struct jffs2_raw_inode *) get_node_mem(b2->offset); 1103 if (jNode->ino == jDirFoundIno) { 1104 src = (unsigned char *)jNode + sizeof(struct jffs2_raw_inode); 1105 1106 #if 0 1107 putLabeledWord("\t\t dsize = ", jNode->dsize); 1108 putstr("\t\t target = "); 1109 putnstr(src, jNode->dsize); 1110 putstr("\r\n"); 1111 #endif 1112 strncpy(tmp, (char *)src, jNode->dsize); 1113 tmp[jNode->dsize] = '\0'; 1114 put_fl_mem(jNode); 1115 break; 1116 } 1117 b2 = b2->next; 1118 put_fl_mem(jNode); 1119 } 1120 /* ok so the name of the new file to find is in tmp */ 1121 /* if it starts with a slash it is root based else shared dirs */ 1122 if (tmp[0] == '/') 1123 pino = 1; 1124 else 1125 pino = jDirFoundPino; 1126 1127 return jffs2_1pass_search_inode(pL, tmp, pino); 1128 } 1129 1130 static u32 1131 jffs2_1pass_search_list_inodes(struct b_lists * pL, const char *fname, u32 pino) 1132 { 1133 int i; 1134 char tmp[256]; 1135 char working_tmp[256]; 1136 char *c; 1137 1138 /* discard any leading slash */ 1139 i = 0; 1140 while (fname[i] == '/') 1141 i++; 1142 strcpy(tmp, &fname[i]); 1143 working_tmp[0] = '\0'; 1144 while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */ 1145 { 1146 strncpy(working_tmp, tmp, c - tmp); 1147 working_tmp[c - tmp] = '\0'; 1148 for (i = 0; i < strlen(c) - 1; i++) 1149 tmp[i] = c[i + 1]; 1150 tmp[i] = '\0'; 1151 /* only a failure if we arent looking at top level */ 1152 if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino)) && 1153 (working_tmp[0])) { 1154 putstr("find_inode failed for name="); 1155 putstr(working_tmp); 1156 putstr("\r\n"); 1157 return 0; 1158 } 1159 } 1160 1161 if (tmp[0] && !(pino = jffs2_1pass_find_inode(pL, tmp, pino))) { 1162 putstr("find_inode failed for name="); 1163 putstr(tmp); 1164 putstr("\r\n"); 1165 return 0; 1166 } 1167 /* this is for the bare filename, directories have already been mapped */ 1168 if (!(pino = jffs2_1pass_list_inodes(pL, pino))) { 1169 putstr("find_inode failed for name="); 1170 putstr(tmp); 1171 putstr("\r\n"); 1172 return 0; 1173 } 1174 return pino; 1175 1176 } 1177 1178 unsigned char 1179 jffs2_1pass_rescan_needed(struct part_info *part) 1180 { 1181 struct b_node *b; 1182 struct jffs2_unknown_node onode; 1183 struct jffs2_unknown_node *node; 1184 struct b_lists *pL = (struct b_lists *)part->jffs2_priv; 1185 1186 if (part->jffs2_priv == 0){ 1187 DEBUGF ("rescan: First time in use\n"); 1188 return 1; 1189 } 1190 1191 /* if we have no list, we need to rescan */ 1192 if (pL->frag.listCount == 0) { 1193 DEBUGF ("rescan: fraglist zero\n"); 1194 return 1; 1195 } 1196 1197 /* but suppose someone reflashed a partition at the same offset... */ 1198 b = pL->dir.listHead; 1199 while (b) { 1200 node = (struct jffs2_unknown_node *) get_fl_mem(b->offset, 1201 sizeof(onode), &onode); 1202 if (node->nodetype != JFFS2_NODETYPE_DIRENT) { 1203 DEBUGF ("rescan: fs changed beneath me? (%lx)\n", 1204 (unsigned long) b->offset); 1205 return 1; 1206 } 1207 b = b->next; 1208 } 1209 return 0; 1210 } 1211 1212 #ifdef DEBUG_FRAGMENTS 1213 static void 1214 dump_fragments(struct b_lists *pL) 1215 { 1216 struct b_node *b; 1217 struct jffs2_raw_inode ojNode; 1218 struct jffs2_raw_inode *jNode; 1219 1220 putstr("\r\n\r\n******The fragment Entries******\r\n"); 1221 b = pL->frag.listHead; 1222 while (b) { 1223 jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 1224 sizeof(ojNode), &ojNode); 1225 putLabeledWord("\r\n\tbuild_list: FLASH_OFFSET = ", b->offset); 1226 putLabeledWord("\tbuild_list: totlen = ", jNode->totlen); 1227 putLabeledWord("\tbuild_list: inode = ", jNode->ino); 1228 putLabeledWord("\tbuild_list: version = ", jNode->version); 1229 putLabeledWord("\tbuild_list: isize = ", jNode->isize); 1230 putLabeledWord("\tbuild_list: atime = ", jNode->atime); 1231 putLabeledWord("\tbuild_list: offset = ", jNode->offset); 1232 putLabeledWord("\tbuild_list: csize = ", jNode->csize); 1233 putLabeledWord("\tbuild_list: dsize = ", jNode->dsize); 1234 putLabeledWord("\tbuild_list: compr = ", jNode->compr); 1235 putLabeledWord("\tbuild_list: usercompr = ", jNode->usercompr); 1236 putLabeledWord("\tbuild_list: flags = ", jNode->flags); 1237 putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */ 1238 b = b->next; 1239 } 1240 } 1241 #endif 1242 1243 #ifdef DEBUG_DIRENTS 1244 static void 1245 dump_dirents(struct b_lists *pL) 1246 { 1247 struct b_node *b; 1248 struct jffs2_raw_dirent *jDir; 1249 1250 putstr("\r\n\r\n******The directory Entries******\r\n"); 1251 b = pL->dir.listHead; 1252 while (b) { 1253 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 1254 putstr("\r\n"); 1255 putnstr(jDir->name, jDir->nsize); 1256 putLabeledWord("\r\n\tbuild_list: magic = ", jDir->magic); 1257 putLabeledWord("\tbuild_list: nodetype = ", jDir->nodetype); 1258 putLabeledWord("\tbuild_list: hdr_crc = ", jDir->hdr_crc); 1259 putLabeledWord("\tbuild_list: pino = ", jDir->pino); 1260 putLabeledWord("\tbuild_list: version = ", jDir->version); 1261 putLabeledWord("\tbuild_list: ino = ", jDir->ino); 1262 putLabeledWord("\tbuild_list: mctime = ", jDir->mctime); 1263 putLabeledWord("\tbuild_list: nsize = ", jDir->nsize); 1264 putLabeledWord("\tbuild_list: type = ", jDir->type); 1265 putLabeledWord("\tbuild_list: node_crc = ", jDir->node_crc); 1266 putLabeledWord("\tbuild_list: name_crc = ", jDir->name_crc); 1267 putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */ 1268 b = b->next; 1269 put_fl_mem(jDir); 1270 } 1271 } 1272 #endif 1273 1274 static u32 1275 jffs2_1pass_build_lists(struct part_info * part) 1276 { 1277 struct b_lists *pL; 1278 struct jffs2_unknown_node *node; 1279 u32 offset, oldoffset = 0; 1280 u32 max = part->size - sizeof(struct jffs2_raw_inode); 1281 u32 counter = 0; 1282 u32 counter4 = 0; 1283 u32 counterF = 0; 1284 u32 counterN = 0; 1285 1286 /* turn off the lcd. Refreshing the lcd adds 50% overhead to the */ 1287 /* jffs2 list building enterprise nope. in newer versions the overhead is */ 1288 /* only about 5 %. not enough to inconvenience people for. */ 1289 /* lcd_off(); */ 1290 1291 /* if we are building a list we need to refresh the cache. */ 1292 jffs_init_1pass_list(part); 1293 pL = (struct b_lists *)part->jffs2_priv; 1294 offset = 0; 1295 puts ("Scanning JFFS2 FS: "); 1296 1297 /* start at the beginning of the partition */ 1298 while (offset < max) { 1299 if ((oldoffset >> SPIN_BLKSIZE) != (offset >> SPIN_BLKSIZE)) { 1300 printf("\b\b%c ", spinner[counter++ % sizeof(spinner)]); 1301 oldoffset = offset; 1302 } 1303 1304 WATCHDOG_RESET(); 1305 1306 node = (struct jffs2_unknown_node *) get_node_mem((u32)part->offset + offset); 1307 if (node->magic == JFFS2_MAGIC_BITMASK && hdr_crc(node)) { 1308 /* if its a fragment add it */ 1309 if (node->nodetype == JFFS2_NODETYPE_INODE && 1310 inode_crc((struct jffs2_raw_inode *) node) && 1311 data_crc((struct jffs2_raw_inode *) node)) { 1312 if (insert_node(&pL->frag, (u32) part->offset + 1313 offset) == NULL) { 1314 put_fl_mem(node); 1315 return 0; 1316 } 1317 } else if (node->nodetype == JFFS2_NODETYPE_DIRENT && 1318 dirent_crc((struct jffs2_raw_dirent *) node) && 1319 dirent_name_crc((struct jffs2_raw_dirent *) node)) { 1320 if (! (counterN%100)) 1321 puts ("\b\b. "); 1322 if (insert_node(&pL->dir, (u32) part->offset + 1323 offset) == NULL) { 1324 put_fl_mem(node); 1325 return 0; 1326 } 1327 counterN++; 1328 } else if (node->nodetype == JFFS2_NODETYPE_CLEANMARKER) { 1329 if (node->totlen != sizeof(struct jffs2_unknown_node)) 1330 printf("OOPS Cleanmarker has bad size " 1331 "%d != %zu\n", 1332 node->totlen, 1333 sizeof(struct jffs2_unknown_node)); 1334 } else if (node->nodetype == JFFS2_NODETYPE_PADDING) { 1335 if (node->totlen < sizeof(struct jffs2_unknown_node)) 1336 printf("OOPS Padding has bad size " 1337 "%d < %zu\n", 1338 node->totlen, 1339 sizeof(struct jffs2_unknown_node)); 1340 } else { 1341 printf("Unknown node type: %x len %d offset 0x%x\n", 1342 node->nodetype, 1343 node->totlen, offset); 1344 } 1345 offset += ((node->totlen + 3) & ~3); 1346 counterF++; 1347 } else if (node->magic == JFFS2_EMPTY_BITMASK && 1348 node->nodetype == JFFS2_EMPTY_BITMASK) { 1349 offset = jffs2_scan_empty(offset, part); 1350 } else { /* if we know nothing, we just step and look. */ 1351 offset += 4; 1352 counter4++; 1353 } 1354 /* printf("unknown node magic %4.4x %4.4x @ %lx\n", node->magic, node->nodetype, (unsigned long)node); */ 1355 put_fl_mem(node); 1356 } 1357 1358 putstr("\b\b done.\r\n"); /* close off the dots */ 1359 /* turn the lcd back on. */ 1360 /* splash(); */ 1361 1362 #if 0 1363 putLabeledWord("dir entries = ", pL->dir.listCount); 1364 putLabeledWord("frag entries = ", pL->frag.listCount); 1365 putLabeledWord("+4 increments = ", counter4); 1366 putLabeledWord("+file_offset increments = ", counterF); 1367 1368 #endif 1369 1370 #ifdef DEBUG_DIRENTS 1371 dump_dirents(pL); 1372 #endif 1373 1374 #ifdef DEBUG_FRAGMENTS 1375 dump_fragments(pL); 1376 #endif 1377 1378 /* give visual feedback that we are done scanning the flash */ 1379 led_blink(0x0, 0x0, 0x1, 0x1); /* off, forever, on 100ms, off 100ms */ 1380 return 1; 1381 } 1382 1383 1384 static u32 1385 jffs2_1pass_fill_info(struct b_lists * pL, struct b_jffs2_info * piL) 1386 { 1387 struct b_node *b; 1388 struct jffs2_raw_inode ojNode; 1389 struct jffs2_raw_inode *jNode; 1390 int i; 1391 1392 for (i = 0; i < JFFS2_NUM_COMPR; i++) { 1393 piL->compr_info[i].num_frags = 0; 1394 piL->compr_info[i].compr_sum = 0; 1395 piL->compr_info[i].decompr_sum = 0; 1396 } 1397 1398 b = pL->frag.listHead; 1399 while (b) { 1400 jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 1401 sizeof(ojNode), &ojNode); 1402 if (jNode->compr < JFFS2_NUM_COMPR) { 1403 piL->compr_info[jNode->compr].num_frags++; 1404 piL->compr_info[jNode->compr].compr_sum += jNode->csize; 1405 piL->compr_info[jNode->compr].decompr_sum += jNode->dsize; 1406 } 1407 b = b->next; 1408 } 1409 return 0; 1410 } 1411 1412 1413 static struct b_lists * 1414 jffs2_get_list(struct part_info * part, const char *who) 1415 { 1416 /* copy requested part_info struct pointer to global location */ 1417 current_part = part; 1418 1419 if (jffs2_1pass_rescan_needed(part)) { 1420 if (!jffs2_1pass_build_lists(part)) { 1421 printf("%s: Failed to scan JFFSv2 file structure\n", who); 1422 return NULL; 1423 } 1424 } 1425 return (struct b_lists *)part->jffs2_priv; 1426 } 1427 1428 1429 /* Print directory / file contents */ 1430 u32 1431 jffs2_1pass_ls(struct part_info * part, const char *fname) 1432 { 1433 struct b_lists *pl; 1434 long ret = 1; 1435 u32 inode; 1436 1437 if (! (pl = jffs2_get_list(part, "ls"))) 1438 return 0; 1439 1440 if (! (inode = jffs2_1pass_search_list_inodes(pl, fname, 1))) { 1441 putstr("ls: Failed to scan jffs2 file structure\r\n"); 1442 return 0; 1443 } 1444 1445 1446 #if 0 1447 putLabeledWord("found file at inode = ", inode); 1448 putLabeledWord("read_inode returns = ", ret); 1449 #endif 1450 1451 return ret; 1452 } 1453 1454 1455 /* Load a file from flash into memory. fname can be a full path */ 1456 u32 1457 jffs2_1pass_load(char *dest, struct part_info * part, const char *fname) 1458 { 1459 1460 struct b_lists *pl; 1461 long ret = 1; 1462 u32 inode; 1463 1464 if (! (pl = jffs2_get_list(part, "load"))) 1465 return 0; 1466 1467 if (! (inode = jffs2_1pass_search_inode(pl, fname, 1))) { 1468 putstr("load: Failed to find inode\r\n"); 1469 return 0; 1470 } 1471 1472 /* Resolve symlinks */ 1473 if (! (inode = jffs2_1pass_resolve_inode(pl, inode))) { 1474 putstr("load: Failed to resolve inode structure\r\n"); 1475 return 0; 1476 } 1477 1478 if ((ret = jffs2_1pass_read_inode(pl, inode, dest)) < 0) { 1479 putstr("load: Failed to read inode\r\n"); 1480 return 0; 1481 } 1482 1483 DEBUGF ("load: loaded '%s' to 0x%lx (%ld bytes)\n", fname, 1484 (unsigned long) dest, ret); 1485 return ret; 1486 } 1487 1488 /* Return information about the fs on this partition */ 1489 u32 1490 jffs2_1pass_info(struct part_info * part) 1491 { 1492 struct b_jffs2_info info; 1493 struct b_lists *pl; 1494 int i; 1495 1496 if (! (pl = jffs2_get_list(part, "info"))) 1497 return 0; 1498 1499 jffs2_1pass_fill_info(pl, &info); 1500 for (i = 0; i < JFFS2_NUM_COMPR; i++) { 1501 printf ("Compression: %s\n" 1502 "\tfrag count: %d\n" 1503 "\tcompressed sum: %d\n" 1504 "\tuncompressed sum: %d\n", 1505 compr_names[i], 1506 info.compr_info[i].num_frags, 1507 info.compr_info[i].compr_sum, 1508 info.compr_info[i].decompr_sum); 1509 } 1510 return 1; 1511 } 1512