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 120 #if defined(CONFIG_CMD_JFFS2) 121 122 #include <jffs2/jffs2.h> 123 #include <jffs2/jffs2_1pass.h> 124 125 #include "jffs2_private.h" 126 127 128 #define NODE_CHUNK 1024 /* size of memory allocation chunk in b_nodes */ 129 #define SPIN_BLKSIZE 18 /* spin after having scanned 1<<BLKSIZE bytes */ 130 131 /* Debugging switches */ 132 #undef DEBUG_DIRENTS /* print directory entry list after scan */ 133 #undef DEBUG_FRAGMENTS /* print fragment list after scan */ 134 #undef DEBUG /* enable debugging messages */ 135 136 137 #ifdef DEBUG 138 # define DEBUGF(fmt,args...) printf(fmt ,##args) 139 #else 140 # define DEBUGF(fmt,args...) 141 #endif 142 143 /* keeps pointer to currentlu processed partition */ 144 static struct part_info *current_part; 145 146 #if (defined(CONFIG_JFFS2_NAND) && \ 147 defined(CONFIG_CMD_NAND) ) 148 #if defined(CFG_NAND_LEGACY) 149 #include <linux/mtd/nand_legacy.h> 150 #else 151 #include <nand.h> 152 #endif 153 /* 154 * Support for jffs2 on top of NAND-flash 155 * 156 * NAND memory isn't mapped in processor's address space, 157 * so data should be fetched from flash before 158 * being processed. This is exactly what functions declared 159 * here do. 160 * 161 */ 162 163 #if defined(CFG_NAND_LEGACY) 164 /* this one defined in nand_legacy.c */ 165 int read_jffs2_nand(size_t start, size_t len, 166 size_t * retlen, u_char * buf, int nanddev); 167 #else 168 /* info for NAND chips, defined in drivers/mtd/nand/nand.c */ 169 extern nand_info_t nand_info[]; 170 #endif 171 172 #define NAND_PAGE_SIZE 512 173 #define NAND_PAGE_SHIFT 9 174 #define NAND_PAGE_MASK (~(NAND_PAGE_SIZE-1)) 175 176 #ifndef NAND_CACHE_PAGES 177 #define NAND_CACHE_PAGES 16 178 #endif 179 #define NAND_CACHE_SIZE (NAND_CACHE_PAGES*NAND_PAGE_SIZE) 180 181 static u8* nand_cache = NULL; 182 static u32 nand_cache_off = (u32)-1; 183 184 static int read_nand_cached(u32 off, u32 size, u_char *buf) 185 { 186 struct mtdids *id = current_part->dev->id; 187 u32 bytes_read = 0; 188 size_t retlen; 189 int cpy_bytes; 190 191 while (bytes_read < size) { 192 if ((off + bytes_read < nand_cache_off) || 193 (off + bytes_read >= nand_cache_off+NAND_CACHE_SIZE)) { 194 nand_cache_off = (off + bytes_read) & NAND_PAGE_MASK; 195 if (!nand_cache) { 196 /* This memory never gets freed but 'cause 197 it's a bootloader, nobody cares */ 198 nand_cache = malloc(NAND_CACHE_SIZE); 199 if (!nand_cache) { 200 printf("read_nand_cached: can't alloc cache size %d bytes\n", 201 NAND_CACHE_SIZE); 202 return -1; 203 } 204 } 205 206 #if defined(CFG_NAND_LEGACY) 207 if (read_jffs2_nand(nand_cache_off, NAND_CACHE_SIZE, 208 &retlen, nand_cache, id->num) < 0 || 209 retlen != NAND_CACHE_SIZE) { 210 printf("read_nand_cached: error reading nand off %#x size %d bytes\n", 211 nand_cache_off, NAND_CACHE_SIZE); 212 return -1; 213 } 214 #else 215 retlen = NAND_CACHE_SIZE; 216 if (nand_read(&nand_info[id->num], nand_cache_off, 217 &retlen, nand_cache) != 0 || 218 retlen != NAND_CACHE_SIZE) { 219 printf("read_nand_cached: error reading nand off %#x size %d bytes\n", 220 nand_cache_off, NAND_CACHE_SIZE); 221 return -1; 222 } 223 #endif 224 } 225 cpy_bytes = nand_cache_off + NAND_CACHE_SIZE - (off + bytes_read); 226 if (cpy_bytes > size - bytes_read) 227 cpy_bytes = size - bytes_read; 228 memcpy(buf + bytes_read, 229 nand_cache + off + bytes_read - nand_cache_off, 230 cpy_bytes); 231 bytes_read += cpy_bytes; 232 } 233 return bytes_read; 234 } 235 236 static void *get_fl_mem_nand(u32 off, u32 size, void *ext_buf) 237 { 238 u_char *buf = ext_buf ? (u_char*)ext_buf : (u_char*)malloc(size); 239 240 if (NULL == buf) { 241 printf("get_fl_mem_nand: can't alloc %d bytes\n", size); 242 return NULL; 243 } 244 if (read_nand_cached(off, size, buf) < 0) { 245 if (!ext_buf) 246 free(buf); 247 return NULL; 248 } 249 250 return buf; 251 } 252 253 static void *get_node_mem_nand(u32 off) 254 { 255 struct jffs2_unknown_node node; 256 void *ret = NULL; 257 258 if (NULL == get_fl_mem_nand(off, sizeof(node), &node)) 259 return NULL; 260 261 if (!(ret = get_fl_mem_nand(off, node.magic == 262 JFFS2_MAGIC_BITMASK ? node.totlen : sizeof(node), 263 NULL))) { 264 printf("off = %#x magic %#x type %#x node.totlen = %d\n", 265 off, node.magic, node.nodetype, node.totlen); 266 } 267 return ret; 268 } 269 270 static void put_fl_mem_nand(void *buf) 271 { 272 free(buf); 273 } 274 #endif 275 276 277 #if defined(CONFIG_CMD_FLASH) 278 /* 279 * Support for jffs2 on top of NOR-flash 280 * 281 * NOR flash memory is mapped in processor's address space, 282 * just return address. 283 */ 284 static inline void *get_fl_mem_nor(u32 off) 285 { 286 u32 addr = off; 287 struct mtdids *id = current_part->dev->id; 288 289 extern flash_info_t flash_info[]; 290 flash_info_t *flash = &flash_info[id->num]; 291 292 addr += flash->start[0]; 293 return (void*)addr; 294 } 295 296 static inline void *get_node_mem_nor(u32 off) 297 { 298 return (void*)get_fl_mem_nor(off); 299 } 300 #endif 301 302 303 /* 304 * Generic jffs2 raw memory and node read routines. 305 * 306 */ 307 static inline void *get_fl_mem(u32 off, u32 size, void *ext_buf) 308 { 309 struct mtdids *id = current_part->dev->id; 310 311 #if defined(CONFIG_CMD_FLASH) 312 if (id->type == MTD_DEV_TYPE_NOR) 313 return get_fl_mem_nor(off); 314 #endif 315 316 #if defined(CONFIG_JFFS2_NAND) && defined(CONFIG_CMD_NAND) 317 if (id->type == MTD_DEV_TYPE_NAND) 318 return get_fl_mem_nand(off, size, ext_buf); 319 #endif 320 321 printf("get_fl_mem: unknown device type, using raw offset!\n"); 322 return (void*)off; 323 } 324 325 static inline void *get_node_mem(u32 off) 326 { 327 struct mtdids *id = current_part->dev->id; 328 329 #if defined(CONFIG_CMD_FLASH) 330 if (id->type == MTD_DEV_TYPE_NOR) 331 return get_node_mem_nor(off); 332 #endif 333 334 #if defined(CONFIG_JFFS2_NAND) && \ 335 defined(CONFIG_CMD_NAND) 336 if (id->type == MTD_DEV_TYPE_NAND) 337 return get_node_mem_nand(off); 338 #endif 339 340 printf("get_node_mem: unknown device type, using raw offset!\n"); 341 return (void*)off; 342 } 343 344 static inline void put_fl_mem(void *buf) 345 { 346 #if defined(CONFIG_JFFS2_NAND) && \ 347 defined(CONFIG_CMD_NAND) 348 struct mtdids *id = current_part->dev->id; 349 350 if (id->type == MTD_DEV_TYPE_NAND) 351 return put_fl_mem_nand(buf); 352 #endif 353 } 354 355 /* Compression names */ 356 static char *compr_names[] = { 357 "NONE", 358 "ZERO", 359 "RTIME", 360 "RUBINMIPS", 361 "COPY", 362 "DYNRUBIN", 363 "ZLIB", 364 #if defined(CONFIG_JFFS2_LZO_LZARI) 365 "LZO", 366 "LZARI", 367 #endif 368 }; 369 370 /* Spinning wheel */ 371 static char spinner[] = { '|', '/', '-', '\\' }; 372 373 /* Memory management */ 374 struct mem_block { 375 u32 index; 376 struct mem_block *next; 377 struct b_node nodes[NODE_CHUNK]; 378 }; 379 380 381 static void 382 free_nodes(struct b_list *list) 383 { 384 while (list->listMemBase != NULL) { 385 struct mem_block *next = list->listMemBase->next; 386 free( list->listMemBase ); 387 list->listMemBase = next; 388 } 389 } 390 391 static struct b_node * 392 add_node(struct b_list *list) 393 { 394 u32 index = 0; 395 struct mem_block *memBase; 396 struct b_node *b; 397 398 memBase = list->listMemBase; 399 if (memBase != NULL) 400 index = memBase->index; 401 #if 0 402 putLabeledWord("add_node: index = ", index); 403 putLabeledWord("add_node: memBase = ", list->listMemBase); 404 #endif 405 406 if (memBase == NULL || index >= NODE_CHUNK) { 407 /* we need more space before we continue */ 408 memBase = mmalloc(sizeof(struct mem_block)); 409 if (memBase == NULL) { 410 putstr("add_node: malloc failed\n"); 411 return NULL; 412 } 413 memBase->next = list->listMemBase; 414 index = 0; 415 #if 0 416 putLabeledWord("add_node: alloced a new membase at ", *memBase); 417 #endif 418 419 } 420 /* now we have room to add it. */ 421 b = &memBase->nodes[index]; 422 index ++; 423 424 memBase->index = index; 425 list->listMemBase = memBase; 426 list->listCount++; 427 return b; 428 } 429 430 static struct b_node * 431 insert_node(struct b_list *list, u32 offset) 432 { 433 struct b_node *new; 434 #ifdef CFG_JFFS2_SORT_FRAGMENTS 435 struct b_node *b, *prev; 436 #endif 437 438 if (!(new = add_node(list))) { 439 putstr("add_node failed!\r\n"); 440 return NULL; 441 } 442 new->offset = offset; 443 444 #ifdef CFG_JFFS2_SORT_FRAGMENTS 445 if (list->listTail != NULL && list->listCompare(new, list->listTail)) 446 prev = list->listTail; 447 else if (list->listLast != NULL && list->listCompare(new, list->listLast)) 448 prev = list->listLast; 449 else 450 prev = NULL; 451 452 for (b = (prev ? prev->next : list->listHead); 453 b != NULL && list->listCompare(new, b); 454 prev = b, b = b->next) { 455 list->listLoops++; 456 } 457 if (b != NULL) 458 list->listLast = prev; 459 460 if (b != NULL) { 461 new->next = b; 462 if (prev != NULL) 463 prev->next = new; 464 else 465 list->listHead = new; 466 } else 467 #endif 468 { 469 new->next = (struct b_node *) NULL; 470 if (list->listTail != NULL) { 471 list->listTail->next = new; 472 list->listTail = new; 473 } else { 474 list->listTail = list->listHead = new; 475 } 476 } 477 478 return new; 479 } 480 481 #ifdef CFG_JFFS2_SORT_FRAGMENTS 482 /* Sort data entries with the latest version last, so that if there 483 * is overlapping data the latest version will be used. 484 */ 485 static int compare_inodes(struct b_node *new, struct b_node *old) 486 { 487 struct jffs2_raw_inode ojNew; 488 struct jffs2_raw_inode ojOld; 489 struct jffs2_raw_inode *jNew = 490 (struct jffs2_raw_inode *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew); 491 struct jffs2_raw_inode *jOld = 492 (struct jffs2_raw_inode *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld); 493 494 return jNew->version > jOld->version; 495 } 496 497 /* Sort directory entries so all entries in the same directory 498 * with the same name are grouped together, with the latest version 499 * last. This makes it easy to eliminate all but the latest version 500 * by marking the previous version dead by setting the inode to 0. 501 */ 502 static int compare_dirents(struct b_node *new, struct b_node *old) 503 { 504 struct jffs2_raw_dirent ojNew; 505 struct jffs2_raw_dirent ojOld; 506 struct jffs2_raw_dirent *jNew = 507 (struct jffs2_raw_dirent *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew); 508 struct jffs2_raw_dirent *jOld = 509 (struct jffs2_raw_dirent *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld); 510 int cmp; 511 512 /* ascending sort by pino */ 513 if (jNew->pino != jOld->pino) 514 return jNew->pino > jOld->pino; 515 516 /* pino is the same, so use ascending sort by nsize, so 517 * we don't do strncmp unless we really must. 518 */ 519 if (jNew->nsize != jOld->nsize) 520 return jNew->nsize > jOld->nsize; 521 522 /* length is also the same, so use ascending sort by name 523 */ 524 cmp = strncmp((char *)jNew->name, (char *)jOld->name, jNew->nsize); 525 if (cmp != 0) 526 return cmp > 0; 527 528 /* we have duplicate names in this directory, so use ascending 529 * sort by version 530 */ 531 if (jNew->version > jOld->version) { 532 /* since jNew is newer, we know jOld is not valid, so 533 * mark it with inode 0 and it will not be used 534 */ 535 jOld->ino = 0; 536 return 1; 537 } 538 539 return 0; 540 } 541 #endif 542 543 static u32 544 jffs2_scan_empty(u32 start_offset, struct part_info *part) 545 { 546 char *max = (char *)(part->offset + part->size - sizeof(struct jffs2_raw_inode)); 547 char *offset = (char *)(part->offset + start_offset); 548 u32 off; 549 550 while (offset < max && 551 *(u32*)get_fl_mem((u32)offset, sizeof(u32), &off) == 0xFFFFFFFF) { 552 offset += sizeof(u32); 553 /* return if spinning is due */ 554 if (((u32)offset & ((1 << SPIN_BLKSIZE)-1)) == 0) break; 555 } 556 557 return (u32)offset - part->offset; 558 } 559 560 void 561 jffs2_free_cache(struct part_info *part) 562 { 563 struct b_lists *pL; 564 565 if (part->jffs2_priv != NULL) { 566 pL = (struct b_lists *)part->jffs2_priv; 567 free_nodes(&pL->frag); 568 free_nodes(&pL->dir); 569 free(pL); 570 } 571 } 572 573 static u32 574 jffs_init_1pass_list(struct part_info *part) 575 { 576 struct b_lists *pL; 577 578 jffs2_free_cache(part); 579 580 if (NULL != (part->jffs2_priv = malloc(sizeof(struct b_lists)))) { 581 pL = (struct b_lists *)part->jffs2_priv; 582 583 memset(pL, 0, sizeof(*pL)); 584 #ifdef CFG_JFFS2_SORT_FRAGMENTS 585 pL->dir.listCompare = compare_dirents; 586 pL->frag.listCompare = compare_inodes; 587 #endif 588 } 589 return 0; 590 } 591 592 /* find the inode from the slashless name given a parent */ 593 static long 594 jffs2_1pass_read_inode(struct b_lists *pL, u32 inode, char *dest) 595 { 596 struct b_node *b; 597 struct jffs2_raw_inode *jNode; 598 u32 totalSize = 0; 599 u32 latestVersion = 0; 600 uchar *lDest; 601 uchar *src; 602 long ret; 603 int i; 604 u32 counter = 0; 605 #ifdef CFG_JFFS2_SORT_FRAGMENTS 606 /* Find file size before loading any data, so fragments that 607 * start past the end of file can be ignored. A fragment 608 * that is partially in the file is loaded, so extra data may 609 * be loaded up to the next 4K boundary above the file size. 610 * This shouldn't cause trouble when loading kernel images, so 611 * we will live with it. 612 */ 613 for (b = pL->frag.listHead; b != NULL; b = b->next) { 614 jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 615 sizeof(struct jffs2_raw_inode), NULL); 616 if ((inode == jNode->ino)) { 617 /* get actual file length from the newest node */ 618 if (jNode->version >= latestVersion) { 619 totalSize = jNode->isize; 620 latestVersion = jNode->version; 621 } 622 } 623 put_fl_mem(jNode); 624 } 625 #endif 626 627 for (b = pL->frag.listHead; b != NULL; b = b->next) { 628 jNode = (struct jffs2_raw_inode *) get_node_mem(b->offset); 629 if ((inode == jNode->ino)) { 630 #if 0 631 putLabeledWord("\r\n\r\nread_inode: totlen = ", jNode->totlen); 632 putLabeledWord("read_inode: inode = ", jNode->ino); 633 putLabeledWord("read_inode: version = ", jNode->version); 634 putLabeledWord("read_inode: isize = ", jNode->isize); 635 putLabeledWord("read_inode: offset = ", jNode->offset); 636 putLabeledWord("read_inode: csize = ", jNode->csize); 637 putLabeledWord("read_inode: dsize = ", jNode->dsize); 638 putLabeledWord("read_inode: compr = ", jNode->compr); 639 putLabeledWord("read_inode: usercompr = ", jNode->usercompr); 640 putLabeledWord("read_inode: flags = ", jNode->flags); 641 #endif 642 643 #ifndef CFG_JFFS2_SORT_FRAGMENTS 644 /* get actual file length from the newest node */ 645 if (jNode->version >= latestVersion) { 646 totalSize = jNode->isize; 647 latestVersion = jNode->version; 648 } 649 #endif 650 651 if(dest) { 652 src = ((uchar *) jNode) + sizeof(struct jffs2_raw_inode); 653 /* ignore data behind latest known EOF */ 654 if (jNode->offset > totalSize) { 655 put_fl_mem(jNode); 656 continue; 657 } 658 659 lDest = (uchar *) (dest + jNode->offset); 660 #if 0 661 putLabeledWord("read_inode: src = ", src); 662 putLabeledWord("read_inode: dest = ", lDest); 663 #endif 664 switch (jNode->compr) { 665 case JFFS2_COMPR_NONE: 666 ret = (unsigned long) ldr_memcpy(lDest, src, jNode->dsize); 667 break; 668 case JFFS2_COMPR_ZERO: 669 ret = 0; 670 for (i = 0; i < jNode->dsize; i++) 671 *(lDest++) = 0; 672 break; 673 case JFFS2_COMPR_RTIME: 674 ret = 0; 675 rtime_decompress(src, lDest, jNode->csize, jNode->dsize); 676 break; 677 case JFFS2_COMPR_DYNRUBIN: 678 /* this is slow but it works */ 679 ret = 0; 680 dynrubin_decompress(src, lDest, jNode->csize, jNode->dsize); 681 break; 682 case JFFS2_COMPR_ZLIB: 683 ret = zlib_decompress(src, lDest, jNode->csize, jNode->dsize); 684 break; 685 #if defined(CONFIG_JFFS2_LZO_LZARI) 686 case JFFS2_COMPR_LZO: 687 ret = lzo_decompress(src, lDest, jNode->csize, jNode->dsize); 688 break; 689 case JFFS2_COMPR_LZARI: 690 ret = lzari_decompress(src, lDest, jNode->csize, jNode->dsize); 691 break; 692 #endif 693 default: 694 /* unknown */ 695 putLabeledWord("UNKOWN COMPRESSION METHOD = ", jNode->compr); 696 put_fl_mem(jNode); 697 return -1; 698 break; 699 } 700 } 701 702 #if 0 703 putLabeledWord("read_inode: totalSize = ", totalSize); 704 putLabeledWord("read_inode: compr ret = ", ret); 705 #endif 706 } 707 counter++; 708 put_fl_mem(jNode); 709 } 710 711 #if 0 712 putLabeledWord("read_inode: returning = ", totalSize); 713 #endif 714 return totalSize; 715 } 716 717 /* find the inode from the slashless name given a parent */ 718 static u32 719 jffs2_1pass_find_inode(struct b_lists * pL, const char *name, u32 pino) 720 { 721 struct b_node *b; 722 struct jffs2_raw_dirent *jDir; 723 int len; 724 u32 counter; 725 u32 version = 0; 726 u32 inode = 0; 727 728 /* name is assumed slash free */ 729 len = strlen(name); 730 731 counter = 0; 732 /* we need to search all and return the inode with the highest version */ 733 for(b = pL->dir.listHead; b; b = b->next, counter++) { 734 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 735 if ((pino == jDir->pino) && (len == jDir->nsize) && 736 (jDir->ino) && /* 0 for unlink */ 737 (!strncmp((char *)jDir->name, name, len))) { /* a match */ 738 if (jDir->version < version) { 739 put_fl_mem(jDir); 740 continue; 741 } 742 743 if (jDir->version == version && inode != 0) { 744 /* I'm pretty sure this isn't legal */ 745 putstr(" ** ERROR ** "); 746 putnstr(jDir->name, jDir->nsize); 747 putLabeledWord(" has dup version =", version); 748 } 749 inode = jDir->ino; 750 version = jDir->version; 751 } 752 #if 0 753 putstr("\r\nfind_inode:p&l ->"); 754 putnstr(jDir->name, jDir->nsize); 755 putstr("\r\n"); 756 putLabeledWord("pino = ", jDir->pino); 757 putLabeledWord("nsize = ", jDir->nsize); 758 putLabeledWord("b = ", (u32) b); 759 putLabeledWord("counter = ", counter); 760 #endif 761 put_fl_mem(jDir); 762 } 763 return inode; 764 } 765 766 char *mkmodestr(unsigned long mode, char *str) 767 { 768 static const char *l = "xwr"; 769 int mask = 1, i; 770 char c; 771 772 switch (mode & S_IFMT) { 773 case S_IFDIR: str[0] = 'd'; break; 774 case S_IFBLK: str[0] = 'b'; break; 775 case S_IFCHR: str[0] = 'c'; break; 776 case S_IFIFO: str[0] = 'f'; break; 777 case S_IFLNK: str[0] = 'l'; break; 778 case S_IFSOCK: str[0] = 's'; break; 779 case S_IFREG: str[0] = '-'; break; 780 default: str[0] = '?'; 781 } 782 783 for(i = 0; i < 9; i++) { 784 c = l[i%3]; 785 str[9-i] = (mode & mask)?c:'-'; 786 mask = mask<<1; 787 } 788 789 if(mode & S_ISUID) str[3] = (mode & S_IXUSR)?'s':'S'; 790 if(mode & S_ISGID) str[6] = (mode & S_IXGRP)?'s':'S'; 791 if(mode & S_ISVTX) str[9] = (mode & S_IXOTH)?'t':'T'; 792 str[10] = '\0'; 793 return str; 794 } 795 796 static inline void dump_stat(struct stat *st, const char *name) 797 { 798 char str[20]; 799 char s[64], *p; 800 801 if (st->st_mtime == (time_t)(-1)) /* some ctimes really hate -1 */ 802 st->st_mtime = 1; 803 804 ctime_r((time_t *)&st->st_mtime, s/*,64*/); /* newlib ctime doesn't have buflen */ 805 806 if ((p = strchr(s,'\n')) != NULL) *p = '\0'; 807 if ((p = strchr(s,'\r')) != NULL) *p = '\0'; 808 809 /* 810 printf("%6lo %s %8ld %s %s\n", st->st_mode, mkmodestr(st->st_mode, str), 811 st->st_size, s, name); 812 */ 813 814 printf(" %s %8ld %s %s", mkmodestr(st->st_mode,str), st->st_size, s, name); 815 } 816 817 static inline u32 dump_inode(struct b_lists * pL, struct jffs2_raw_dirent *d, struct jffs2_raw_inode *i) 818 { 819 char fname[256]; 820 struct stat st; 821 822 if(!d || !i) return -1; 823 824 strncpy(fname, (char *)d->name, d->nsize); 825 fname[d->nsize] = '\0'; 826 827 memset(&st,0,sizeof(st)); 828 829 st.st_mtime = i->mtime; 830 st.st_mode = i->mode; 831 st.st_ino = i->ino; 832 833 /* neither dsize nor isize help us.. do it the long way */ 834 st.st_size = jffs2_1pass_read_inode(pL, i->ino, NULL); 835 836 dump_stat(&st, fname); 837 838 if (d->type == DT_LNK) { 839 unsigned char *src = (unsigned char *) (&i[1]); 840 putstr(" -> "); 841 putnstr(src, (int)i->dsize); 842 } 843 844 putstr("\r\n"); 845 846 return 0; 847 } 848 849 /* list inodes with the given pino */ 850 static u32 851 jffs2_1pass_list_inodes(struct b_lists * pL, u32 pino) 852 { 853 struct b_node *b; 854 struct jffs2_raw_dirent *jDir; 855 856 for (b = pL->dir.listHead; b; b = b->next) { 857 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 858 if ((pino == jDir->pino) && (jDir->ino)) { /* ino=0 -> unlink */ 859 u32 i_version = 0; 860 struct jffs2_raw_inode ojNode; 861 struct jffs2_raw_inode *jNode, *i = NULL; 862 struct b_node *b2 = pL->frag.listHead; 863 864 while (b2) { 865 jNode = (struct jffs2_raw_inode *) 866 get_fl_mem(b2->offset, sizeof(ojNode), &ojNode); 867 if (jNode->ino == jDir->ino && jNode->version >= i_version) { 868 if (i) 869 put_fl_mem(i); 870 871 if (jDir->type == DT_LNK) 872 i = get_node_mem(b2->offset); 873 else 874 i = get_fl_mem(b2->offset, sizeof(*i), NULL); 875 } 876 b2 = b2->next; 877 } 878 879 dump_inode(pL, jDir, i); 880 put_fl_mem(i); 881 } 882 put_fl_mem(jDir); 883 } 884 return pino; 885 } 886 887 static u32 888 jffs2_1pass_search_inode(struct b_lists * pL, const char *fname, u32 pino) 889 { 890 int i; 891 char tmp[256]; 892 char working_tmp[256]; 893 char *c; 894 895 /* discard any leading slash */ 896 i = 0; 897 while (fname[i] == '/') 898 i++; 899 strcpy(tmp, &fname[i]); 900 901 while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */ 902 { 903 strncpy(working_tmp, tmp, c - tmp); 904 working_tmp[c - tmp] = '\0'; 905 #if 0 906 putstr("search_inode: tmp = "); 907 putstr(tmp); 908 putstr("\r\n"); 909 putstr("search_inode: wtmp = "); 910 putstr(working_tmp); 911 putstr("\r\n"); 912 putstr("search_inode: c = "); 913 putstr(c); 914 putstr("\r\n"); 915 #endif 916 for (i = 0; i < strlen(c) - 1; i++) 917 tmp[i] = c[i + 1]; 918 tmp[i] = '\0'; 919 #if 0 920 putstr("search_inode: post tmp = "); 921 putstr(tmp); 922 putstr("\r\n"); 923 #endif 924 925 if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino))) { 926 putstr("find_inode failed for name="); 927 putstr(working_tmp); 928 putstr("\r\n"); 929 return 0; 930 } 931 } 932 /* this is for the bare filename, directories have already been mapped */ 933 if (!(pino = jffs2_1pass_find_inode(pL, tmp, pino))) { 934 putstr("find_inode failed for name="); 935 putstr(tmp); 936 putstr("\r\n"); 937 return 0; 938 } 939 return pino; 940 941 } 942 943 static u32 944 jffs2_1pass_resolve_inode(struct b_lists * pL, u32 ino) 945 { 946 struct b_node *b; 947 struct b_node *b2; 948 struct jffs2_raw_dirent *jDir; 949 struct jffs2_raw_inode *jNode; 950 u8 jDirFoundType = 0; 951 u32 jDirFoundIno = 0; 952 u32 jDirFoundPino = 0; 953 char tmp[256]; 954 u32 version = 0; 955 u32 pino; 956 unsigned char *src; 957 958 /* we need to search all and return the inode with the highest version */ 959 for(b = pL->dir.listHead; b; b = b->next) { 960 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 961 if (ino == jDir->ino) { 962 if (jDir->version < version) { 963 put_fl_mem(jDir); 964 continue; 965 } 966 967 if (jDir->version == version && jDirFoundType) { 968 /* I'm pretty sure this isn't legal */ 969 putstr(" ** ERROR ** "); 970 putnstr(jDir->name, jDir->nsize); 971 putLabeledWord(" has dup version (resolve) = ", 972 version); 973 } 974 975 jDirFoundType = jDir->type; 976 jDirFoundIno = jDir->ino; 977 jDirFoundPino = jDir->pino; 978 version = jDir->version; 979 } 980 put_fl_mem(jDir); 981 } 982 /* now we found the right entry again. (shoulda returned inode*) */ 983 if (jDirFoundType != DT_LNK) 984 return jDirFoundIno; 985 986 /* it's a soft link so we follow it again. */ 987 b2 = pL->frag.listHead; 988 while (b2) { 989 jNode = (struct jffs2_raw_inode *) get_node_mem(b2->offset); 990 if (jNode->ino == jDirFoundIno) { 991 src = (unsigned char *)jNode + sizeof(struct jffs2_raw_inode); 992 993 #if 0 994 putLabeledWord("\t\t dsize = ", jNode->dsize); 995 putstr("\t\t target = "); 996 putnstr(src, jNode->dsize); 997 putstr("\r\n"); 998 #endif 999 strncpy(tmp, (char *)src, jNode->dsize); 1000 tmp[jNode->dsize] = '\0'; 1001 put_fl_mem(jNode); 1002 break; 1003 } 1004 b2 = b2->next; 1005 put_fl_mem(jNode); 1006 } 1007 /* ok so the name of the new file to find is in tmp */ 1008 /* if it starts with a slash it is root based else shared dirs */ 1009 if (tmp[0] == '/') 1010 pino = 1; 1011 else 1012 pino = jDirFoundPino; 1013 1014 return jffs2_1pass_search_inode(pL, tmp, pino); 1015 } 1016 1017 static u32 1018 jffs2_1pass_search_list_inodes(struct b_lists * pL, const char *fname, u32 pino) 1019 { 1020 int i; 1021 char tmp[256]; 1022 char working_tmp[256]; 1023 char *c; 1024 1025 /* discard any leading slash */ 1026 i = 0; 1027 while (fname[i] == '/') 1028 i++; 1029 strcpy(tmp, &fname[i]); 1030 working_tmp[0] = '\0'; 1031 while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */ 1032 { 1033 strncpy(working_tmp, tmp, c - tmp); 1034 working_tmp[c - tmp] = '\0'; 1035 for (i = 0; i < strlen(c) - 1; i++) 1036 tmp[i] = c[i + 1]; 1037 tmp[i] = '\0'; 1038 /* only a failure if we arent looking at top level */ 1039 if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino)) && 1040 (working_tmp[0])) { 1041 putstr("find_inode failed for name="); 1042 putstr(working_tmp); 1043 putstr("\r\n"); 1044 return 0; 1045 } 1046 } 1047 1048 if (tmp[0] && !(pino = jffs2_1pass_find_inode(pL, tmp, pino))) { 1049 putstr("find_inode failed for name="); 1050 putstr(tmp); 1051 putstr("\r\n"); 1052 return 0; 1053 } 1054 /* this is for the bare filename, directories have already been mapped */ 1055 if (!(pino = jffs2_1pass_list_inodes(pL, pino))) { 1056 putstr("find_inode failed for name="); 1057 putstr(tmp); 1058 putstr("\r\n"); 1059 return 0; 1060 } 1061 return pino; 1062 1063 } 1064 1065 unsigned char 1066 jffs2_1pass_rescan_needed(struct part_info *part) 1067 { 1068 struct b_node *b; 1069 struct jffs2_unknown_node onode; 1070 struct jffs2_unknown_node *node; 1071 struct b_lists *pL = (struct b_lists *)part->jffs2_priv; 1072 1073 if (part->jffs2_priv == 0){ 1074 DEBUGF ("rescan: First time in use\n"); 1075 return 1; 1076 } 1077 1078 /* if we have no list, we need to rescan */ 1079 if (pL->frag.listCount == 0) { 1080 DEBUGF ("rescan: fraglist zero\n"); 1081 return 1; 1082 } 1083 1084 /* but suppose someone reflashed a partition at the same offset... */ 1085 b = pL->dir.listHead; 1086 while (b) { 1087 node = (struct jffs2_unknown_node *) get_fl_mem(b->offset, 1088 sizeof(onode), &onode); 1089 if (node->nodetype != JFFS2_NODETYPE_DIRENT) { 1090 DEBUGF ("rescan: fs changed beneath me? (%lx)\n", 1091 (unsigned long) b->offset); 1092 return 1; 1093 } 1094 b = b->next; 1095 } 1096 return 0; 1097 } 1098 1099 #ifdef DEBUG_FRAGMENTS 1100 static void 1101 dump_fragments(struct b_lists *pL) 1102 { 1103 struct b_node *b; 1104 struct jffs2_raw_inode ojNode; 1105 struct jffs2_raw_inode *jNode; 1106 1107 putstr("\r\n\r\n******The fragment Entries******\r\n"); 1108 b = pL->frag.listHead; 1109 while (b) { 1110 jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 1111 sizeof(ojNode), &ojNode); 1112 putLabeledWord("\r\n\tbuild_list: FLASH_OFFSET = ", b->offset); 1113 putLabeledWord("\tbuild_list: totlen = ", jNode->totlen); 1114 putLabeledWord("\tbuild_list: inode = ", jNode->ino); 1115 putLabeledWord("\tbuild_list: version = ", jNode->version); 1116 putLabeledWord("\tbuild_list: isize = ", jNode->isize); 1117 putLabeledWord("\tbuild_list: atime = ", jNode->atime); 1118 putLabeledWord("\tbuild_list: offset = ", jNode->offset); 1119 putLabeledWord("\tbuild_list: csize = ", jNode->csize); 1120 putLabeledWord("\tbuild_list: dsize = ", jNode->dsize); 1121 putLabeledWord("\tbuild_list: compr = ", jNode->compr); 1122 putLabeledWord("\tbuild_list: usercompr = ", jNode->usercompr); 1123 putLabeledWord("\tbuild_list: flags = ", jNode->flags); 1124 putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */ 1125 b = b->next; 1126 } 1127 } 1128 #endif 1129 1130 #ifdef DEBUG_DIRENTS 1131 static void 1132 dump_dirents(struct b_lists *pL) 1133 { 1134 struct b_node *b; 1135 struct jffs2_raw_dirent *jDir; 1136 1137 putstr("\r\n\r\n******The directory Entries******\r\n"); 1138 b = pL->dir.listHead; 1139 while (b) { 1140 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 1141 putstr("\r\n"); 1142 putnstr(jDir->name, jDir->nsize); 1143 putLabeledWord("\r\n\tbuild_list: magic = ", jDir->magic); 1144 putLabeledWord("\tbuild_list: nodetype = ", jDir->nodetype); 1145 putLabeledWord("\tbuild_list: hdr_crc = ", jDir->hdr_crc); 1146 putLabeledWord("\tbuild_list: pino = ", jDir->pino); 1147 putLabeledWord("\tbuild_list: version = ", jDir->version); 1148 putLabeledWord("\tbuild_list: ino = ", jDir->ino); 1149 putLabeledWord("\tbuild_list: mctime = ", jDir->mctime); 1150 putLabeledWord("\tbuild_list: nsize = ", jDir->nsize); 1151 putLabeledWord("\tbuild_list: type = ", jDir->type); 1152 putLabeledWord("\tbuild_list: node_crc = ", jDir->node_crc); 1153 putLabeledWord("\tbuild_list: name_crc = ", jDir->name_crc); 1154 putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */ 1155 b = b->next; 1156 put_fl_mem(jDir); 1157 } 1158 } 1159 #endif 1160 1161 static u32 1162 jffs2_1pass_build_lists(struct part_info * part) 1163 { 1164 struct b_lists *pL; 1165 struct jffs2_unknown_node *node; 1166 u32 offset, oldoffset = 0; 1167 u32 max = part->size - sizeof(struct jffs2_raw_inode); 1168 u32 counter = 0; 1169 u32 counter4 = 0; 1170 u32 counterF = 0; 1171 u32 counterN = 0; 1172 1173 /* turn off the lcd. Refreshing the lcd adds 50% overhead to the */ 1174 /* jffs2 list building enterprise nope. in newer versions the overhead is */ 1175 /* only about 5 %. not enough to inconvenience people for. */ 1176 /* lcd_off(); */ 1177 1178 /* if we are building a list we need to refresh the cache. */ 1179 jffs_init_1pass_list(part); 1180 pL = (struct b_lists *)part->jffs2_priv; 1181 offset = 0; 1182 puts ("Scanning JFFS2 FS: "); 1183 1184 /* start at the beginning of the partition */ 1185 while (offset < max) { 1186 if ((oldoffset >> SPIN_BLKSIZE) != (offset >> SPIN_BLKSIZE)) { 1187 printf("\b\b%c ", spinner[counter++ % sizeof(spinner)]); 1188 oldoffset = offset; 1189 } 1190 1191 node = (struct jffs2_unknown_node *) get_node_mem((u32)part->offset + offset); 1192 if (node->magic == JFFS2_MAGIC_BITMASK && hdr_crc(node)) { 1193 /* if its a fragment add it */ 1194 if (node->nodetype == JFFS2_NODETYPE_INODE && 1195 inode_crc((struct jffs2_raw_inode *) node) && 1196 data_crc((struct jffs2_raw_inode *) node)) { 1197 if (insert_node(&pL->frag, (u32) part->offset + 1198 offset) == NULL) { 1199 put_fl_mem(node); 1200 return 0; 1201 } 1202 } else if (node->nodetype == JFFS2_NODETYPE_DIRENT && 1203 dirent_crc((struct jffs2_raw_dirent *) node) && 1204 dirent_name_crc((struct jffs2_raw_dirent *) node)) { 1205 if (! (counterN%100)) 1206 puts ("\b\b. "); 1207 if (insert_node(&pL->dir, (u32) part->offset + 1208 offset) == NULL) { 1209 put_fl_mem(node); 1210 return 0; 1211 } 1212 counterN++; 1213 } else if (node->nodetype == JFFS2_NODETYPE_CLEANMARKER) { 1214 if (node->totlen != sizeof(struct jffs2_unknown_node)) 1215 printf("OOPS Cleanmarker has bad size " 1216 "%d != %d\n", node->totlen, 1217 sizeof(struct jffs2_unknown_node)); 1218 } else if (node->nodetype == JFFS2_NODETYPE_PADDING) { 1219 if (node->totlen < sizeof(struct jffs2_unknown_node)) 1220 printf("OOPS Padding has bad size " 1221 "%d < %d\n", node->totlen, 1222 sizeof(struct jffs2_unknown_node)); 1223 } else { 1224 printf("Unknown node type: %x len %d " 1225 "offset 0x%x\n", node->nodetype, 1226 node->totlen, offset); 1227 } 1228 offset += ((node->totlen + 3) & ~3); 1229 counterF++; 1230 } else if (node->magic == JFFS2_EMPTY_BITMASK && 1231 node->nodetype == JFFS2_EMPTY_BITMASK) { 1232 offset = jffs2_scan_empty(offset, part); 1233 } else { /* if we know nothing, we just step and look. */ 1234 offset += 4; 1235 counter4++; 1236 } 1237 /* printf("unknown node magic %4.4x %4.4x @ %lx\n", node->magic, node->nodetype, (unsigned long)node); */ 1238 put_fl_mem(node); 1239 } 1240 1241 putstr("\b\b done.\r\n"); /* close off the dots */ 1242 /* turn the lcd back on. */ 1243 /* splash(); */ 1244 1245 #if 0 1246 putLabeledWord("dir entries = ", pL->dir.listCount); 1247 putLabeledWord("frag entries = ", pL->frag.listCount); 1248 putLabeledWord("+4 increments = ", counter4); 1249 putLabeledWord("+file_offset increments = ", counterF); 1250 1251 #endif 1252 1253 #ifdef DEBUG_DIRENTS 1254 dump_dirents(pL); 1255 #endif 1256 1257 #ifdef DEBUG_FRAGMENTS 1258 dump_fragments(pL); 1259 #endif 1260 1261 /* give visual feedback that we are done scanning the flash */ 1262 led_blink(0x0, 0x0, 0x1, 0x1); /* off, forever, on 100ms, off 100ms */ 1263 return 1; 1264 } 1265 1266 1267 static u32 1268 jffs2_1pass_fill_info(struct b_lists * pL, struct b_jffs2_info * piL) 1269 { 1270 struct b_node *b; 1271 struct jffs2_raw_inode ojNode; 1272 struct jffs2_raw_inode *jNode; 1273 int i; 1274 1275 for (i = 0; i < JFFS2_NUM_COMPR; i++) { 1276 piL->compr_info[i].num_frags = 0; 1277 piL->compr_info[i].compr_sum = 0; 1278 piL->compr_info[i].decompr_sum = 0; 1279 } 1280 1281 b = pL->frag.listHead; 1282 while (b) { 1283 jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 1284 sizeof(ojNode), &ojNode); 1285 if (jNode->compr < JFFS2_NUM_COMPR) { 1286 piL->compr_info[jNode->compr].num_frags++; 1287 piL->compr_info[jNode->compr].compr_sum += jNode->csize; 1288 piL->compr_info[jNode->compr].decompr_sum += jNode->dsize; 1289 } 1290 b = b->next; 1291 } 1292 return 0; 1293 } 1294 1295 1296 static struct b_lists * 1297 jffs2_get_list(struct part_info * part, const char *who) 1298 { 1299 /* copy requested part_info struct pointer to global location */ 1300 current_part = part; 1301 1302 if (jffs2_1pass_rescan_needed(part)) { 1303 if (!jffs2_1pass_build_lists(part)) { 1304 printf("%s: Failed to scan JFFSv2 file structure\n", who); 1305 return NULL; 1306 } 1307 } 1308 return (struct b_lists *)part->jffs2_priv; 1309 } 1310 1311 1312 /* Print directory / file contents */ 1313 u32 1314 jffs2_1pass_ls(struct part_info * part, const char *fname) 1315 { 1316 struct b_lists *pl; 1317 long ret = 1; 1318 u32 inode; 1319 1320 if (! (pl = jffs2_get_list(part, "ls"))) 1321 return 0; 1322 1323 if (! (inode = jffs2_1pass_search_list_inodes(pl, fname, 1))) { 1324 putstr("ls: Failed to scan jffs2 file structure\r\n"); 1325 return 0; 1326 } 1327 1328 1329 #if 0 1330 putLabeledWord("found file at inode = ", inode); 1331 putLabeledWord("read_inode returns = ", ret); 1332 #endif 1333 1334 return ret; 1335 } 1336 1337 1338 /* Load a file from flash into memory. fname can be a full path */ 1339 u32 1340 jffs2_1pass_load(char *dest, struct part_info * part, const char *fname) 1341 { 1342 1343 struct b_lists *pl; 1344 long ret = 1; 1345 u32 inode; 1346 1347 if (! (pl = jffs2_get_list(part, "load"))) 1348 return 0; 1349 1350 if (! (inode = jffs2_1pass_search_inode(pl, fname, 1))) { 1351 putstr("load: Failed to find inode\r\n"); 1352 return 0; 1353 } 1354 1355 /* Resolve symlinks */ 1356 if (! (inode = jffs2_1pass_resolve_inode(pl, inode))) { 1357 putstr("load: Failed to resolve inode structure\r\n"); 1358 return 0; 1359 } 1360 1361 if ((ret = jffs2_1pass_read_inode(pl, inode, dest)) < 0) { 1362 putstr("load: Failed to read inode\r\n"); 1363 return 0; 1364 } 1365 1366 DEBUGF ("load: loaded '%s' to 0x%lx (%ld bytes)\n", fname, 1367 (unsigned long) dest, ret); 1368 return ret; 1369 } 1370 1371 /* Return information about the fs on this partition */ 1372 u32 1373 jffs2_1pass_info(struct part_info * part) 1374 { 1375 struct b_jffs2_info info; 1376 struct b_lists *pl; 1377 int i; 1378 1379 if (! (pl = jffs2_get_list(part, "info"))) 1380 return 0; 1381 1382 jffs2_1pass_fill_info(pl, &info); 1383 for (i = 0; i < JFFS2_NUM_COMPR; i++) { 1384 printf ("Compression: %s\n" 1385 "\tfrag count: %d\n" 1386 "\tcompressed sum: %d\n" 1387 "\tuncompressed sum: %d\n", 1388 compr_names[i], 1389 info.compr_info[i].num_frags, 1390 info.compr_info[i].compr_sum, 1391 info.compr_info[i].decompr_sum); 1392 } 1393 return 1; 1394 } 1395 1396 #endif 1397