1fe8c2806Swdenk /* 2fe8c2806Swdenk ------------------------------------------------------------------------- 3fe8c2806Swdenk * Filename: jffs2.c 4fe8c2806Swdenk * Version: $Id: jffs2_1pass.c,v 1.7 2002/01/25 01:56:47 nyet Exp $ 5fe8c2806Swdenk * Copyright: Copyright (C) 2001, Russ Dill 6fe8c2806Swdenk * Author: Russ Dill <Russ.Dill@asu.edu> 7fe8c2806Swdenk * Description: Module to load kernel from jffs2 8fe8c2806Swdenk *-----------------------------------------------------------------------*/ 9fe8c2806Swdenk /* 10fe8c2806Swdenk * some portions of this code are taken from jffs2, and as such, the 11fe8c2806Swdenk * following copyright notice is included. 12fe8c2806Swdenk * 13fe8c2806Swdenk * JFFS2 -- Journalling Flash File System, Version 2. 14fe8c2806Swdenk * 15fe8c2806Swdenk * Copyright (C) 2001 Red Hat, Inc. 16fe8c2806Swdenk * 17fe8c2806Swdenk * Created by David Woodhouse <dwmw2@cambridge.redhat.com> 18fe8c2806Swdenk * 19fe8c2806Swdenk * The original JFFS, from which the design for JFFS2 was derived, 20fe8c2806Swdenk * was designed and implemented by Axis Communications AB. 21fe8c2806Swdenk * 22fe8c2806Swdenk * The contents of this file are subject to the Red Hat eCos Public 23fe8c2806Swdenk * License Version 1.1 (the "Licence"); you may not use this file 24fe8c2806Swdenk * except in compliance with the Licence. You may obtain a copy of 25fe8c2806Swdenk * the Licence at http://www.redhat.com/ 26fe8c2806Swdenk * 27fe8c2806Swdenk * Software distributed under the Licence is distributed on an "AS IS" 28fe8c2806Swdenk * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. 29fe8c2806Swdenk * See the Licence for the specific language governing rights and 30fe8c2806Swdenk * limitations under the Licence. 31fe8c2806Swdenk * 32fe8c2806Swdenk * The Original Code is JFFS2 - Journalling Flash File System, version 2 33fe8c2806Swdenk * 34fe8c2806Swdenk * Alternatively, the contents of this file may be used under the 35fe8c2806Swdenk * terms of the GNU General Public License version 2 (the "GPL"), in 36fe8c2806Swdenk * which case the provisions of the GPL are applicable instead of the 37fe8c2806Swdenk * above. If you wish to allow the use of your version of this file 38fe8c2806Swdenk * only under the terms of the GPL and not to allow others to use your 39fe8c2806Swdenk * version of this file under the RHEPL, indicate your decision by 40fe8c2806Swdenk * deleting the provisions above and replace them with the notice and 41fe8c2806Swdenk * other provisions required by the GPL. If you do not delete the 42fe8c2806Swdenk * provisions above, a recipient may use your version of this file 43fe8c2806Swdenk * under either the RHEPL or the GPL. 44fe8c2806Swdenk * 45fe8c2806Swdenk * $Id: jffs2_1pass.c,v 1.7 2002/01/25 01:56:47 nyet Exp $ 46fe8c2806Swdenk * 47fe8c2806Swdenk */ 48fe8c2806Swdenk 49fe8c2806Swdenk /* Ok, so anyone who knows the jffs2 code will probably want to get a papar 50fe8c2806Swdenk * bag to throw up into before reading this code. I looked through the jffs2 51fe8c2806Swdenk * code, the caching scheme is very elegant. I tried to keep the version 52fe8c2806Swdenk * for a bootloader as small and simple as possible. Instead of worring about 53fe8c2806Swdenk * unneccesary data copies, node scans, etc, I just optimized for the known 54fe8c2806Swdenk * common case, a kernel, which looks like: 55fe8c2806Swdenk * (1) most pages are 4096 bytes 56fe8c2806Swdenk * (2) version numbers are somewhat sorted in acsending order 57fe8c2806Swdenk * (3) multiple compressed blocks making up one page is uncommon 58fe8c2806Swdenk * 59fe8c2806Swdenk * So I create a linked list of decending version numbers (insertions at the 60fe8c2806Swdenk * head), and then for each page, walk down the list, until a matching page 61fe8c2806Swdenk * with 4096 bytes is found, and then decompress the watching pages in 62fe8c2806Swdenk * reverse order. 63fe8c2806Swdenk * 64fe8c2806Swdenk */ 65fe8c2806Swdenk 66fe8c2806Swdenk /* 67fe8c2806Swdenk * Adapted by Nye Liu <nyet@zumanetworks.com> and 68fe8c2806Swdenk * Rex Feany <rfeany@zumanetworks.com> 69fe8c2806Swdenk * on Jan/2002 for U-Boot. 70fe8c2806Swdenk * 71fe8c2806Swdenk * Clipped out all the non-1pass functions, cleaned up warnings, 72fe8c2806Swdenk * wrappers, etc. No major changes to the code. 73fe8c2806Swdenk * Please, he really means it when he said have a paper bag 74fe8c2806Swdenk * handy. We needed it ;). 75fe8c2806Swdenk * 76fe8c2806Swdenk */ 77fe8c2806Swdenk 7806d01dbeSwdenk /* 7906d01dbeSwdenk * Bugfixing by Kai-Uwe Bloem <kai-uwe.bloem@auerswald.de>, (C) Mar/2003 8006d01dbeSwdenk * 8106d01dbeSwdenk * - overhaul of the memory management. Removed much of the "paper-bagging" 8206d01dbeSwdenk * in that part of the code, fixed several bugs, now frees memory when 8306d01dbeSwdenk * partition is changed. 8406d01dbeSwdenk * It's still ugly :-( 8506d01dbeSwdenk * - fixed a bug in jffs2_1pass_read_inode where the file length calculation 8606d01dbeSwdenk * was incorrect. Removed a bit of the paper-bagging as well. 8706d01dbeSwdenk * - removed double crc calculation for fragment headers in jffs2_private.h 8806d01dbeSwdenk * for speedup. 8906d01dbeSwdenk * - scan_empty rewritten in a more "standard" manner (non-paperbag, that is). 9006d01dbeSwdenk * - spinning wheel now spins depending on how much memory has been scanned 9106d01dbeSwdenk * - lots of small changes all over the place to "improve" readability. 9206d01dbeSwdenk * - implemented fragment sorting to ensure that the newest data is copied 9306d01dbeSwdenk * if there are multiple copies of fragments for a certain file offset. 9406d01dbeSwdenk * 9506d01dbeSwdenk * The fragment sorting feature must be enabled by CFG_JFFS2_SORT_FRAGMENTS. 9606d01dbeSwdenk * Sorting is done while adding fragments to the lists, which is more or less a 9706d01dbeSwdenk * bubble sort. This takes a lot of time, and is most probably not an issue if 9806d01dbeSwdenk * the boot filesystem is always mounted readonly. 9906d01dbeSwdenk * 10006d01dbeSwdenk * You should define it if the boot filesystem is mounted writable, and updates 10106d01dbeSwdenk * to the boot files are done by copying files to that filesystem. 10206d01dbeSwdenk * 10306d01dbeSwdenk * 10406d01dbeSwdenk * There's a big issue left: endianess is completely ignored in this code. Duh! 10506d01dbeSwdenk * 10606d01dbeSwdenk * 10706d01dbeSwdenk * You still should have paper bags at hand :-(. The code lacks more or less 10806d01dbeSwdenk * any comment, and is still arcane and difficult to read in places. As this 109dd875c76Swdenk * might be incompatible with any new code from the jffs2 maintainers anyway, 110dd875c76Swdenk * it should probably be dumped and replaced by something like jffs2reader! 11106d01dbeSwdenk */ 11206d01dbeSwdenk 11306d01dbeSwdenk 114fe8c2806Swdenk #include <common.h> 115fe8c2806Swdenk #include <config.h> 116fe8c2806Swdenk #include <malloc.h> 117fe8c2806Swdenk #include <linux/stat.h> 118fe8c2806Swdenk #include <linux/time.h> 119fe8c2806Swdenk 1204e109ae9SJon Loeliger #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) || defined(CONFIG_CMD_JFFS2) 121fe8c2806Swdenk 122fe8c2806Swdenk #include <jffs2/jffs2.h> 123fe8c2806Swdenk #include <jffs2/jffs2_1pass.h> 124fe8c2806Swdenk 125fe8c2806Swdenk #include "jffs2_private.h" 126fe8c2806Swdenk 12706d01dbeSwdenk 12806d01dbeSwdenk #define NODE_CHUNK 1024 /* size of memory allocation chunk in b_nodes */ 129fc1cfcdbSwdenk #define SPIN_BLKSIZE 18 /* spin after having scanned 1<<BLKSIZE bytes */ 13006d01dbeSwdenk 13106d01dbeSwdenk /* Debugging switches */ 13206d01dbeSwdenk #undef DEBUG_DIRENTS /* print directory entry list after scan */ 13306d01dbeSwdenk #undef DEBUG_FRAGMENTS /* print fragment list after scan */ 13406d01dbeSwdenk #undef DEBUG /* enable debugging messages */ 13506d01dbeSwdenk 13606d01dbeSwdenk 13706d01dbeSwdenk #ifdef DEBUG 13806d01dbeSwdenk # define DEBUGF(fmt,args...) printf(fmt ,##args) 13906d01dbeSwdenk #else 14006d01dbeSwdenk # define DEBUGF(fmt,args...) 14106d01dbeSwdenk #endif 14206d01dbeSwdenk 143700a0c64SWolfgang Denk /* keeps pointer to currentlu processed partition */ 144700a0c64SWolfgang Denk static struct part_info *current_part; 145998eaaecSwdenk 146*e4dbe1b2SWolfgang Denk #if (defined(CONFIG_JFFS2_NAND) && \ 147*e4dbe1b2SWolfgang Denk ((CONFIG_COMMANDS & CFG_CMD_NAND) || defined(CONFIG_CMD_NAND)) ) 1486db39708SMarian Balakowicz #if defined(CFG_NAND_LEGACY) 1496db39708SMarian Balakowicz #include <linux/mtd/nand_legacy.h> 1506db39708SMarian Balakowicz #else 151addb2e16SBartlomiej Sieka #include <nand.h> 1526db39708SMarian Balakowicz #endif 153998eaaecSwdenk /* 154998eaaecSwdenk * Support for jffs2 on top of NAND-flash 155998eaaecSwdenk * 156998eaaecSwdenk * NAND memory isn't mapped in processor's address space, 157998eaaecSwdenk * so data should be fetched from flash before 158998eaaecSwdenk * being processed. This is exactly what functions declared 159998eaaecSwdenk * here do. 160998eaaecSwdenk * 161998eaaecSwdenk */ 162998eaaecSwdenk 1636db39708SMarian Balakowicz #if defined(CFG_NAND_LEGACY) 1646db39708SMarian Balakowicz /* this one defined in nand_legacy.c */ 1656db39708SMarian Balakowicz int read_jffs2_nand(size_t start, size_t len, 1666db39708SMarian Balakowicz size_t * retlen, u_char * buf, int nanddev); 1676db39708SMarian Balakowicz #else 168addb2e16SBartlomiej Sieka /* info for NAND chips, defined in drivers/nand/nand.c */ 169addb2e16SBartlomiej Sieka extern nand_info_t nand_info[]; 1706db39708SMarian Balakowicz #endif 171998eaaecSwdenk 172998eaaecSwdenk #define NAND_PAGE_SIZE 512 173998eaaecSwdenk #define NAND_PAGE_SHIFT 9 174998eaaecSwdenk #define NAND_PAGE_MASK (~(NAND_PAGE_SIZE-1)) 175998eaaecSwdenk 176998eaaecSwdenk #ifndef NAND_CACHE_PAGES 177998eaaecSwdenk #define NAND_CACHE_PAGES 16 178998eaaecSwdenk #endif 179998eaaecSwdenk #define NAND_CACHE_SIZE (NAND_CACHE_PAGES*NAND_PAGE_SIZE) 180998eaaecSwdenk 181998eaaecSwdenk static u8* nand_cache = NULL; 182998eaaecSwdenk static u32 nand_cache_off = (u32)-1; 183998eaaecSwdenk 184998eaaecSwdenk static int read_nand_cached(u32 off, u32 size, u_char *buf) 185998eaaecSwdenk { 186700a0c64SWolfgang Denk struct mtdids *id = current_part->dev->id; 187998eaaecSwdenk u32 bytes_read = 0; 1886db39708SMarian Balakowicz #if defined(CFG_NAND_LEGACY) 1896db39708SMarian Balakowicz size_t retlen; 1906db39708SMarian Balakowicz #else 191addb2e16SBartlomiej Sieka ulong retlen; 1926db39708SMarian Balakowicz #endif 193998eaaecSwdenk int cpy_bytes; 194998eaaecSwdenk 195998eaaecSwdenk while (bytes_read < size) { 196998eaaecSwdenk if ((off + bytes_read < nand_cache_off) || 197998eaaecSwdenk (off + bytes_read >= nand_cache_off+NAND_CACHE_SIZE)) { 198998eaaecSwdenk nand_cache_off = (off + bytes_read) & NAND_PAGE_MASK; 199998eaaecSwdenk if (!nand_cache) { 200998eaaecSwdenk /* This memory never gets freed but 'cause 201998eaaecSwdenk it's a bootloader, nobody cares */ 202998eaaecSwdenk nand_cache = malloc(NAND_CACHE_SIZE); 203998eaaecSwdenk if (!nand_cache) { 204998eaaecSwdenk printf("read_nand_cached: can't alloc cache size %d bytes\n", 205998eaaecSwdenk NAND_CACHE_SIZE); 206998eaaecSwdenk return -1; 207998eaaecSwdenk } 208998eaaecSwdenk } 209addb2e16SBartlomiej Sieka 2106db39708SMarian Balakowicz #if defined(CFG_NAND_LEGACY) 2116db39708SMarian Balakowicz if (read_jffs2_nand(nand_cache_off, NAND_CACHE_SIZE, 2126db39708SMarian Balakowicz &retlen, nand_cache, id->num) < 0 || 2136db39708SMarian Balakowicz retlen != NAND_CACHE_SIZE) { 2146db39708SMarian Balakowicz printf("read_nand_cached: error reading nand off %#x size %d bytes\n", 2156db39708SMarian Balakowicz nand_cache_off, NAND_CACHE_SIZE); 2166db39708SMarian Balakowicz return -1; 2176db39708SMarian Balakowicz } 2186db39708SMarian Balakowicz #else 219addb2e16SBartlomiej Sieka retlen = NAND_CACHE_SIZE; 220addb2e16SBartlomiej Sieka if (nand_read(&nand_info[id->num], nand_cache_off, 221addb2e16SBartlomiej Sieka &retlen, nand_cache) != 0 || 222998eaaecSwdenk retlen != NAND_CACHE_SIZE) { 223998eaaecSwdenk printf("read_nand_cached: error reading nand off %#x size %d bytes\n", 224998eaaecSwdenk nand_cache_off, NAND_CACHE_SIZE); 225998eaaecSwdenk return -1; 226998eaaecSwdenk } 2276db39708SMarian Balakowicz #endif 228998eaaecSwdenk } 229998eaaecSwdenk cpy_bytes = nand_cache_off + NAND_CACHE_SIZE - (off + bytes_read); 230998eaaecSwdenk if (cpy_bytes > size - bytes_read) 231998eaaecSwdenk cpy_bytes = size - bytes_read; 232998eaaecSwdenk memcpy(buf + bytes_read, 233998eaaecSwdenk nand_cache + off + bytes_read - nand_cache_off, 234998eaaecSwdenk cpy_bytes); 235998eaaecSwdenk bytes_read += cpy_bytes; 236998eaaecSwdenk } 237998eaaecSwdenk return bytes_read; 238998eaaecSwdenk } 239998eaaecSwdenk 240700a0c64SWolfgang Denk static void *get_fl_mem_nand(u32 off, u32 size, void *ext_buf) 241998eaaecSwdenk { 242998eaaecSwdenk u_char *buf = ext_buf ? (u_char*)ext_buf : (u_char*)malloc(size); 243998eaaecSwdenk 244998eaaecSwdenk if (NULL == buf) { 245700a0c64SWolfgang Denk printf("get_fl_mem_nand: can't alloc %d bytes\n", size); 246998eaaecSwdenk return NULL; 247998eaaecSwdenk } 248998eaaecSwdenk if (read_nand_cached(off, size, buf) < 0) { 24932877d66Swdenk if (!ext_buf) 250998eaaecSwdenk free(buf); 251998eaaecSwdenk return NULL; 252998eaaecSwdenk } 253998eaaecSwdenk 254998eaaecSwdenk return buf; 255998eaaecSwdenk } 256998eaaecSwdenk 257700a0c64SWolfgang Denk static void *get_node_mem_nand(u32 off) 258998eaaecSwdenk { 259998eaaecSwdenk struct jffs2_unknown_node node; 260998eaaecSwdenk void *ret = NULL; 261998eaaecSwdenk 262700a0c64SWolfgang Denk if (NULL == get_fl_mem_nand(off, sizeof(node), &node)) 263998eaaecSwdenk return NULL; 264998eaaecSwdenk 265700a0c64SWolfgang Denk if (!(ret = get_fl_mem_nand(off, node.magic == 266998eaaecSwdenk JFFS2_MAGIC_BITMASK ? node.totlen : sizeof(node), 267998eaaecSwdenk NULL))) { 268998eaaecSwdenk printf("off = %#x magic %#x type %#x node.totlen = %d\n", 269998eaaecSwdenk off, node.magic, node.nodetype, node.totlen); 270998eaaecSwdenk } 271998eaaecSwdenk return ret; 272998eaaecSwdenk } 273998eaaecSwdenk 274700a0c64SWolfgang Denk static void put_fl_mem_nand(void *buf) 275998eaaecSwdenk { 276998eaaecSwdenk free(buf); 277998eaaecSwdenk } 278700a0c64SWolfgang Denk #endif /* #if defined(CONFIG_JFFS2_NAND) && (CONFIG_COMMANDS & CFG_CMD_NAND) */ 279998eaaecSwdenk 280998eaaecSwdenk 2814e109ae9SJon Loeliger #if (CONFIG_COMMANDS & CFG_CMD_FLASH) || defined(CONFIG_CMD_FLASH) 282700a0c64SWolfgang Denk /* 283700a0c64SWolfgang Denk * Support for jffs2 on top of NOR-flash 284700a0c64SWolfgang Denk * 285700a0c64SWolfgang Denk * NOR flash memory is mapped in processor's address space, 286700a0c64SWolfgang Denk * just return address. 287700a0c64SWolfgang Denk */ 288700a0c64SWolfgang Denk static inline void *get_fl_mem_nor(u32 off) 289700a0c64SWolfgang Denk { 290700a0c64SWolfgang Denk u32 addr = off; 291700a0c64SWolfgang Denk struct mtdids *id = current_part->dev->id; 292700a0c64SWolfgang Denk 293e6f2e902SMarian Balakowicz extern flash_info_t flash_info[]; 294700a0c64SWolfgang Denk flash_info_t *flash = &flash_info[id->num]; 295700a0c64SWolfgang Denk 296700a0c64SWolfgang Denk addr += flash->start[0]; 297700a0c64SWolfgang Denk return (void*)addr; 298700a0c64SWolfgang Denk } 299700a0c64SWolfgang Denk 300700a0c64SWolfgang Denk static inline void *get_node_mem_nor(u32 off) 301700a0c64SWolfgang Denk { 302700a0c64SWolfgang Denk return (void*)get_fl_mem_nor(off); 303700a0c64SWolfgang Denk } 304700a0c64SWolfgang Denk #endif /* #if (CONFIG_COMMANDS & CFG_CMD_FLASH) */ 305700a0c64SWolfgang Denk 306700a0c64SWolfgang Denk 307700a0c64SWolfgang Denk /* 308700a0c64SWolfgang Denk * Generic jffs2 raw memory and node read routines. 309700a0c64SWolfgang Denk * 310700a0c64SWolfgang Denk */ 311998eaaecSwdenk static inline void *get_fl_mem(u32 off, u32 size, void *ext_buf) 312998eaaecSwdenk { 313700a0c64SWolfgang Denk struct mtdids *id = current_part->dev->id; 314700a0c64SWolfgang Denk 3154e109ae9SJon Loeliger #if (CONFIG_COMMANDS & CFG_CMD_FLASH) || defined(CONFIG_CMD_FLASH) 316700a0c64SWolfgang Denk if (id->type == MTD_DEV_TYPE_NOR) 317700a0c64SWolfgang Denk return get_fl_mem_nor(off); 318700a0c64SWolfgang Denk #endif 319700a0c64SWolfgang Denk 3204e109ae9SJon Loeliger #if defined(CONFIG_JFFS2_NAND) && ((CONFIG_COMMANDS & CFG_CMD_NAND) || defined(CONFIG_CMD_NAND)) 321700a0c64SWolfgang Denk if (id->type == MTD_DEV_TYPE_NAND) 322700a0c64SWolfgang Denk return get_fl_mem_nand(off, size, ext_buf); 323700a0c64SWolfgang Denk #endif 324700a0c64SWolfgang Denk 325700a0c64SWolfgang Denk printf("get_fl_mem: unknown device type, using raw offset!\n"); 326998eaaecSwdenk return (void*)off; 327998eaaecSwdenk } 328998eaaecSwdenk 329998eaaecSwdenk static inline void *get_node_mem(u32 off) 330998eaaecSwdenk { 331700a0c64SWolfgang Denk struct mtdids *id = current_part->dev->id; 332700a0c64SWolfgang Denk 3334e109ae9SJon Loeliger #if (CONFIG_COMMANDS & CFG_CMD_FLASH) || defined(CONFIG_CMD_FLASH) 334700a0c64SWolfgang Denk if (id->type == MTD_DEV_TYPE_NOR) 335700a0c64SWolfgang Denk return get_node_mem_nor(off); 336700a0c64SWolfgang Denk #endif 337700a0c64SWolfgang Denk 338*e4dbe1b2SWolfgang Denk #if defined(CONFIG_JFFS2_NAND) && \ 339*e4dbe1b2SWolfgang Denk (CONFIG_COMMANDS & CFG_CMD_NAND) || defined(CONFIG_CMD_NAND) 340700a0c64SWolfgang Denk if (id->type == MTD_DEV_TYPE_NAND) 341700a0c64SWolfgang Denk return get_node_mem_nand(off); 342700a0c64SWolfgang Denk #endif 343700a0c64SWolfgang Denk 344700a0c64SWolfgang Denk printf("get_node_mem: unknown device type, using raw offset!\n"); 345998eaaecSwdenk return (void*)off; 346998eaaecSwdenk } 347998eaaecSwdenk 348998eaaecSwdenk static inline void put_fl_mem(void *buf) 349998eaaecSwdenk { 350*e4dbe1b2SWolfgang Denk #if defined(CONFIG_JFFS2_NAND) && \ 351*e4dbe1b2SWolfgang Denk (CONFIG_COMMANDS & CFG_CMD_NAND) || defined(CONFIG_CMD_NAND) 352700a0c64SWolfgang Denk struct mtdids *id = current_part->dev->id; 353700a0c64SWolfgang Denk 354700a0c64SWolfgang Denk if (id->type == MTD_DEV_TYPE_NAND) 355700a0c64SWolfgang Denk return put_fl_mem_nand(buf); 356700a0c64SWolfgang Denk #endif 357998eaaecSwdenk } 358998eaaecSwdenk 359fe8c2806Swdenk /* Compression names */ 360fe8c2806Swdenk static char *compr_names[] = { 361fe8c2806Swdenk "NONE", 362fe8c2806Swdenk "ZERO", 363fe8c2806Swdenk "RTIME", 364fe8c2806Swdenk "RUBINMIPS", 365fe8c2806Swdenk "COPY", 366fe8c2806Swdenk "DYNRUBIN", 36707cc0999Swdenk "ZLIB", 368412babe3Swdenk #if defined(CONFIG_JFFS2_LZO_LZARI) 36907cc0999Swdenk "LZO", 37007cc0999Swdenk "LZARI", 37107cc0999Swdenk #endif 37206d01dbeSwdenk }; 373fe8c2806Swdenk 37406d01dbeSwdenk /* Spinning wheel */ 37506d01dbeSwdenk static char spinner[] = { '|', '/', '-', '\\' }; 376fe8c2806Swdenk 37706d01dbeSwdenk /* Memory management */ 37806d01dbeSwdenk struct mem_block { 37906d01dbeSwdenk u32 index; 38006d01dbeSwdenk struct mem_block *next; 38106d01dbeSwdenk struct b_node nodes[NODE_CHUNK]; 38206d01dbeSwdenk }; 383fe8c2806Swdenk 384fe8c2806Swdenk 38506d01dbeSwdenk static void 38606d01dbeSwdenk free_nodes(struct b_list *list) 38706d01dbeSwdenk { 38806d01dbeSwdenk while (list->listMemBase != NULL) { 38906d01dbeSwdenk struct mem_block *next = list->listMemBase->next; 39006d01dbeSwdenk free( list->listMemBase ); 39106d01dbeSwdenk list->listMemBase = next; 39206d01dbeSwdenk } 39306d01dbeSwdenk } 394fe8c2806Swdenk 395fe8c2806Swdenk static struct b_node * 39606d01dbeSwdenk add_node(struct b_list *list) 397fe8c2806Swdenk { 39806d01dbeSwdenk u32 index = 0; 39906d01dbeSwdenk struct mem_block *memBase; 400fe8c2806Swdenk struct b_node *b; 401fe8c2806Swdenk 40206d01dbeSwdenk memBase = list->listMemBase; 40306d01dbeSwdenk if (memBase != NULL) 40406d01dbeSwdenk index = memBase->index; 405fe8c2806Swdenk #if 0 406fe8c2806Swdenk putLabeledWord("add_node: index = ", index); 40706d01dbeSwdenk putLabeledWord("add_node: memBase = ", list->listMemBase); 408fe8c2806Swdenk #endif 409fe8c2806Swdenk 41006d01dbeSwdenk if (memBase == NULL || index >= NODE_CHUNK) { 41106d01dbeSwdenk /* we need more space before we continue */ 41206d01dbeSwdenk memBase = mmalloc(sizeof(struct mem_block)); 41306d01dbeSwdenk if (memBase == NULL) { 414fe8c2806Swdenk putstr("add_node: malloc failed\n"); 415fe8c2806Swdenk return NULL; 416fe8c2806Swdenk } 41706d01dbeSwdenk memBase->next = list->listMemBase; 41806d01dbeSwdenk index = 0; 419fe8c2806Swdenk #if 0 420fe8c2806Swdenk putLabeledWord("add_node: alloced a new membase at ", *memBase); 421fe8c2806Swdenk #endif 422fe8c2806Swdenk 423fe8c2806Swdenk } 424fe8c2806Swdenk /* now we have room to add it. */ 42506d01dbeSwdenk b = &memBase->nodes[index]; 42606d01dbeSwdenk index ++; 427fe8c2806Swdenk 42806d01dbeSwdenk memBase->index = index; 42906d01dbeSwdenk list->listMemBase = memBase; 43006d01dbeSwdenk list->listCount++; 431fe8c2806Swdenk return b; 432fe8c2806Swdenk } 433fe8c2806Swdenk 43406d01dbeSwdenk static struct b_node * 43506d01dbeSwdenk insert_node(struct b_list *list, u32 offset) 43606d01dbeSwdenk { 43706d01dbeSwdenk struct b_node *new; 43806d01dbeSwdenk #ifdef CFG_JFFS2_SORT_FRAGMENTS 43906d01dbeSwdenk struct b_node *b, *prev; 44006d01dbeSwdenk #endif 44106d01dbeSwdenk 44206d01dbeSwdenk if (!(new = add_node(list))) { 44306d01dbeSwdenk putstr("add_node failed!\r\n"); 44406d01dbeSwdenk return NULL; 44506d01dbeSwdenk } 44606d01dbeSwdenk new->offset = offset; 44706d01dbeSwdenk 44806d01dbeSwdenk #ifdef CFG_JFFS2_SORT_FRAGMENTS 44906d01dbeSwdenk if (list->listTail != NULL && list->listCompare(new, list->listTail)) 45006d01dbeSwdenk prev = list->listTail; 45106d01dbeSwdenk else if (list->listLast != NULL && list->listCompare(new, list->listLast)) 45206d01dbeSwdenk prev = list->listLast; 45306d01dbeSwdenk else 45406d01dbeSwdenk prev = NULL; 45506d01dbeSwdenk 45606d01dbeSwdenk for (b = (prev ? prev->next : list->listHead); 45706d01dbeSwdenk b != NULL && list->listCompare(new, b); 45806d01dbeSwdenk prev = b, b = b->next) { 45906d01dbeSwdenk list->listLoops++; 46006d01dbeSwdenk } 46106d01dbeSwdenk if (b != NULL) 46206d01dbeSwdenk list->listLast = prev; 46306d01dbeSwdenk 46406d01dbeSwdenk if (b != NULL) { 46506d01dbeSwdenk new->next = b; 46606d01dbeSwdenk if (prev != NULL) 46706d01dbeSwdenk prev->next = new; 46806d01dbeSwdenk else 46906d01dbeSwdenk list->listHead = new; 47006d01dbeSwdenk } else 47106d01dbeSwdenk #endif 47206d01dbeSwdenk { 47306d01dbeSwdenk new->next = (struct b_node *) NULL; 47406d01dbeSwdenk if (list->listTail != NULL) { 47506d01dbeSwdenk list->listTail->next = new; 47606d01dbeSwdenk list->listTail = new; 47706d01dbeSwdenk } else { 47806d01dbeSwdenk list->listTail = list->listHead = new; 47906d01dbeSwdenk } 48006d01dbeSwdenk } 48106d01dbeSwdenk 48206d01dbeSwdenk return new; 48306d01dbeSwdenk } 48406d01dbeSwdenk 48506d01dbeSwdenk #ifdef CFG_JFFS2_SORT_FRAGMENTS 4867205e407Swdenk /* Sort data entries with the latest version last, so that if there 4877205e407Swdenk * is overlapping data the latest version will be used. 4887205e407Swdenk */ 48906d01dbeSwdenk static int compare_inodes(struct b_node *new, struct b_node *old) 49006d01dbeSwdenk { 491998eaaecSwdenk struct jffs2_raw_inode ojNew; 492998eaaecSwdenk struct jffs2_raw_inode ojOld; 493998eaaecSwdenk struct jffs2_raw_inode *jNew = 494998eaaecSwdenk (struct jffs2_raw_inode *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew); 495998eaaecSwdenk struct jffs2_raw_inode *jOld = 496998eaaecSwdenk (struct jffs2_raw_inode *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld); 49706d01dbeSwdenk 4987205e407Swdenk return jNew->version > jOld->version; 49906d01dbeSwdenk } 50006d01dbeSwdenk 5017205e407Swdenk /* Sort directory entries so all entries in the same directory 5027205e407Swdenk * with the same name are grouped together, with the latest version 5037205e407Swdenk * last. This makes it easy to eliminate all but the latest version 5047205e407Swdenk * by marking the previous version dead by setting the inode to 0. 5057205e407Swdenk */ 50606d01dbeSwdenk static int compare_dirents(struct b_node *new, struct b_node *old) 50706d01dbeSwdenk { 508998eaaecSwdenk struct jffs2_raw_dirent ojNew; 509998eaaecSwdenk struct jffs2_raw_dirent ojOld; 510998eaaecSwdenk struct jffs2_raw_dirent *jNew = 511998eaaecSwdenk (struct jffs2_raw_dirent *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew); 512998eaaecSwdenk struct jffs2_raw_dirent *jOld = 513998eaaecSwdenk (struct jffs2_raw_dirent *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld); 5147205e407Swdenk int cmp; 51506d01dbeSwdenk 5167205e407Swdenk /* ascending sort by pino */ 5177205e407Swdenk if (jNew->pino != jOld->pino) 5187205e407Swdenk return jNew->pino > jOld->pino; 5197205e407Swdenk 5207205e407Swdenk /* pino is the same, so use ascending sort by nsize, so 5217205e407Swdenk * we don't do strncmp unless we really must. 5227205e407Swdenk */ 5237205e407Swdenk if (jNew->nsize != jOld->nsize) 5247205e407Swdenk return jNew->nsize > jOld->nsize; 5257205e407Swdenk 5267205e407Swdenk /* length is also the same, so use ascending sort by name 5277205e407Swdenk */ 52877ddac94SWolfgang Denk cmp = strncmp((char *)jNew->name, (char *)jOld->name, jNew->nsize); 5297205e407Swdenk if (cmp != 0) 5307205e407Swdenk return cmp > 0; 5317205e407Swdenk 5327205e407Swdenk /* we have duplicate names in this directory, so use ascending 5337205e407Swdenk * sort by version 5347205e407Swdenk */ 5357205e407Swdenk if (jNew->version > jOld->version) { 5367205e407Swdenk /* since jNew is newer, we know jOld is not valid, so 5377205e407Swdenk * mark it with inode 0 and it will not be used 5387205e407Swdenk */ 5397205e407Swdenk jOld->ino = 0; 5407205e407Swdenk return 1; 5417205e407Swdenk } 5427205e407Swdenk 5437205e407Swdenk return 0; 54406d01dbeSwdenk } 54506d01dbeSwdenk #endif 546fe8c2806Swdenk 547fe8c2806Swdenk static u32 548fe8c2806Swdenk jffs2_scan_empty(u32 start_offset, struct part_info *part) 549fe8c2806Swdenk { 550700a0c64SWolfgang Denk char *max = (char *)(part->offset + part->size - sizeof(struct jffs2_raw_inode)); 551700a0c64SWolfgang Denk char *offset = (char *)(part->offset + start_offset); 552998eaaecSwdenk u32 off; 553fe8c2806Swdenk 554998eaaecSwdenk while (offset < max && 555998eaaecSwdenk *(u32*)get_fl_mem((u32)offset, sizeof(u32), &off) == 0xFFFFFFFF) { 55606d01dbeSwdenk offset += sizeof(u32); 55706d01dbeSwdenk /* return if spinning is due */ 55806d01dbeSwdenk if (((u32)offset & ((1 << SPIN_BLKSIZE)-1)) == 0) break; 55906d01dbeSwdenk } 560fc1cfcdbSwdenk 561700a0c64SWolfgang Denk return (u32)offset - part->offset; 562fe8c2806Swdenk } 563fe8c2806Swdenk 564700a0c64SWolfgang Denk void 565700a0c64SWolfgang Denk jffs2_free_cache(struct part_info *part) 566fe8c2806Swdenk { 56706d01dbeSwdenk struct b_lists *pL; 568fe8c2806Swdenk 56906d01dbeSwdenk if (part->jffs2_priv != NULL) { 57006d01dbeSwdenk pL = (struct b_lists *)part->jffs2_priv; 57106d01dbeSwdenk free_nodes(&pL->frag); 57206d01dbeSwdenk free_nodes(&pL->dir); 57306d01dbeSwdenk free(pL); 57406d01dbeSwdenk } 575700a0c64SWolfgang Denk } 576700a0c64SWolfgang Denk 577700a0c64SWolfgang Denk static u32 578700a0c64SWolfgang Denk jffs_init_1pass_list(struct part_info *part) 579700a0c64SWolfgang Denk { 580700a0c64SWolfgang Denk struct b_lists *pL; 581700a0c64SWolfgang Denk 582700a0c64SWolfgang Denk jffs2_free_cache(part); 583700a0c64SWolfgang Denk 58406d01dbeSwdenk if (NULL != (part->jffs2_priv = malloc(sizeof(struct b_lists)))) { 58506d01dbeSwdenk pL = (struct b_lists *)part->jffs2_priv; 58606d01dbeSwdenk 58706d01dbeSwdenk memset(pL, 0, sizeof(*pL)); 58806d01dbeSwdenk #ifdef CFG_JFFS2_SORT_FRAGMENTS 58906d01dbeSwdenk pL->dir.listCompare = compare_dirents; 59006d01dbeSwdenk pL->frag.listCompare = compare_inodes; 59106d01dbeSwdenk #endif 592fe8c2806Swdenk } 593fe8c2806Swdenk return 0; 594fe8c2806Swdenk } 595fe8c2806Swdenk 596fe8c2806Swdenk /* find the inode from the slashless name given a parent */ 597fe8c2806Swdenk static long 598fe8c2806Swdenk jffs2_1pass_read_inode(struct b_lists *pL, u32 inode, char *dest) 599fe8c2806Swdenk { 600fe8c2806Swdenk struct b_node *b; 601fe8c2806Swdenk struct jffs2_raw_inode *jNode; 60206d01dbeSwdenk u32 totalSize = 0; 6037205e407Swdenk u32 latestVersion = 0; 60477ddac94SWolfgang Denk uchar *lDest; 60577ddac94SWolfgang Denk uchar *src; 606fe8c2806Swdenk long ret; 607fe8c2806Swdenk int i; 608fe8c2806Swdenk u32 counter = 0; 6097205e407Swdenk #ifdef CFG_JFFS2_SORT_FRAGMENTS 6107205e407Swdenk /* Find file size before loading any data, so fragments that 6117205e407Swdenk * start past the end of file can be ignored. A fragment 6127205e407Swdenk * that is partially in the file is loaded, so extra data may 6137205e407Swdenk * be loaded up to the next 4K boundary above the file size. 6147205e407Swdenk * This shouldn't cause trouble when loading kernel images, so 6157205e407Swdenk * we will live with it. 6167205e407Swdenk */ 6177205e407Swdenk for (b = pL->frag.listHead; b != NULL; b = b->next) { 618998eaaecSwdenk jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 619998eaaecSwdenk sizeof(struct jffs2_raw_inode), NULL); 6207205e407Swdenk if ((inode == jNode->ino)) { 6217205e407Swdenk /* get actual file length from the newest node */ 6227205e407Swdenk if (jNode->version >= latestVersion) { 6237205e407Swdenk totalSize = jNode->isize; 6247205e407Swdenk latestVersion = jNode->version; 6257205e407Swdenk } 6267205e407Swdenk } 627998eaaecSwdenk put_fl_mem(jNode); 6287205e407Swdenk } 6297205e407Swdenk #endif 630fe8c2806Swdenk 63106d01dbeSwdenk for (b = pL->frag.listHead; b != NULL; b = b->next) { 632998eaaecSwdenk jNode = (struct jffs2_raw_inode *) get_node_mem(b->offset); 633fe8c2806Swdenk if ((inode == jNode->ino)) { 63406d01dbeSwdenk #if 0 635fe8c2806Swdenk putLabeledWord("\r\n\r\nread_inode: totlen = ", jNode->totlen); 636fe8c2806Swdenk putLabeledWord("read_inode: inode = ", jNode->ino); 637fe8c2806Swdenk putLabeledWord("read_inode: version = ", jNode->version); 638fe8c2806Swdenk putLabeledWord("read_inode: isize = ", jNode->isize); 639fe8c2806Swdenk putLabeledWord("read_inode: offset = ", jNode->offset); 640fe8c2806Swdenk putLabeledWord("read_inode: csize = ", jNode->csize); 641fe8c2806Swdenk putLabeledWord("read_inode: dsize = ", jNode->dsize); 642fe8c2806Swdenk putLabeledWord("read_inode: compr = ", jNode->compr); 643fe8c2806Swdenk putLabeledWord("read_inode: usercompr = ", jNode->usercompr); 644fe8c2806Swdenk putLabeledWord("read_inode: flags = ", jNode->flags); 645fe8c2806Swdenk #endif 6467205e407Swdenk 6477205e407Swdenk #ifndef CFG_JFFS2_SORT_FRAGMENTS 64806d01dbeSwdenk /* get actual file length from the newest node */ 64906d01dbeSwdenk if (jNode->version >= latestVersion) { 650fe8c2806Swdenk totalSize = jNode->isize; 65106d01dbeSwdenk latestVersion = jNode->version; 652fe8c2806Swdenk } 6537205e407Swdenk #endif 654fe8c2806Swdenk 655fe8c2806Swdenk if(dest) { 65677ddac94SWolfgang Denk src = ((uchar *) jNode) + sizeof(struct jffs2_raw_inode); 65706d01dbeSwdenk /* ignore data behind latest known EOF */ 658998eaaecSwdenk if (jNode->offset > totalSize) { 659998eaaecSwdenk put_fl_mem(jNode); 66006d01dbeSwdenk continue; 661998eaaecSwdenk } 66206d01dbeSwdenk 66377ddac94SWolfgang Denk lDest = (uchar *) (dest + jNode->offset); 664fe8c2806Swdenk #if 0 66506d01dbeSwdenk putLabeledWord("read_inode: src = ", src); 666fe8c2806Swdenk putLabeledWord("read_inode: dest = ", lDest); 667fe8c2806Swdenk #endif 668fe8c2806Swdenk switch (jNode->compr) { 669fe8c2806Swdenk case JFFS2_COMPR_NONE: 670fe8c2806Swdenk ret = (unsigned long) ldr_memcpy(lDest, src, jNode->dsize); 671fe8c2806Swdenk break; 672fe8c2806Swdenk case JFFS2_COMPR_ZERO: 673fe8c2806Swdenk ret = 0; 674fe8c2806Swdenk for (i = 0; i < jNode->dsize; i++) 675fe8c2806Swdenk *(lDest++) = 0; 676fe8c2806Swdenk break; 677fe8c2806Swdenk case JFFS2_COMPR_RTIME: 678fe8c2806Swdenk ret = 0; 679fe8c2806Swdenk rtime_decompress(src, lDest, jNode->csize, jNode->dsize); 680fe8c2806Swdenk break; 681fe8c2806Swdenk case JFFS2_COMPR_DYNRUBIN: 682fe8c2806Swdenk /* this is slow but it works */ 683fe8c2806Swdenk ret = 0; 684fe8c2806Swdenk dynrubin_decompress(src, lDest, jNode->csize, jNode->dsize); 685fe8c2806Swdenk break; 686fe8c2806Swdenk case JFFS2_COMPR_ZLIB: 687fe8c2806Swdenk ret = zlib_decompress(src, lDest, jNode->csize, jNode->dsize); 688fe8c2806Swdenk break; 689412babe3Swdenk #if defined(CONFIG_JFFS2_LZO_LZARI) 69007cc0999Swdenk case JFFS2_COMPR_LZO: 69107cc0999Swdenk ret = lzo_decompress(src, lDest, jNode->csize, jNode->dsize); 69207cc0999Swdenk break; 693412babe3Swdenk case JFFS2_COMPR_LZARI: 694412babe3Swdenk ret = lzari_decompress(src, lDest, jNode->csize, jNode->dsize); 695412babe3Swdenk break; 69607cc0999Swdenk #endif 697fe8c2806Swdenk default: 698fe8c2806Swdenk /* unknown */ 699fe8c2806Swdenk putLabeledWord("UNKOWN COMPRESSION METHOD = ", jNode->compr); 700998eaaecSwdenk put_fl_mem(jNode); 701fe8c2806Swdenk return -1; 702fe8c2806Swdenk break; 703fe8c2806Swdenk } 704fe8c2806Swdenk } 705fe8c2806Swdenk 706fe8c2806Swdenk #if 0 707fe8c2806Swdenk putLabeledWord("read_inode: totalSize = ", totalSize); 708fe8c2806Swdenk putLabeledWord("read_inode: compr ret = ", ret); 709fe8c2806Swdenk #endif 710fe8c2806Swdenk } 711fe8c2806Swdenk counter++; 712998eaaecSwdenk put_fl_mem(jNode); 713fe8c2806Swdenk } 714fe8c2806Swdenk 715fe8c2806Swdenk #if 0 71606d01dbeSwdenk putLabeledWord("read_inode: returning = ", totalSize); 717fe8c2806Swdenk #endif 71806d01dbeSwdenk return totalSize; 719fe8c2806Swdenk } 720fe8c2806Swdenk 721fe8c2806Swdenk /* find the inode from the slashless name given a parent */ 722fe8c2806Swdenk static u32 723fe8c2806Swdenk jffs2_1pass_find_inode(struct b_lists * pL, const char *name, u32 pino) 724fe8c2806Swdenk { 725fe8c2806Swdenk struct b_node *b; 726fe8c2806Swdenk struct jffs2_raw_dirent *jDir; 727fe8c2806Swdenk int len; 728fe8c2806Swdenk u32 counter; 729fe8c2806Swdenk u32 version = 0; 730fe8c2806Swdenk u32 inode = 0; 731fe8c2806Swdenk 732fe8c2806Swdenk /* name is assumed slash free */ 733fe8c2806Swdenk len = strlen(name); 734fe8c2806Swdenk 735fe8c2806Swdenk counter = 0; 736fe8c2806Swdenk /* we need to search all and return the inode with the highest version */ 73706d01dbeSwdenk for(b = pL->dir.listHead; b; b = b->next, counter++) { 738998eaaecSwdenk jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 73906d01dbeSwdenk if ((pino == jDir->pino) && (len == jDir->nsize) && 74006d01dbeSwdenk (jDir->ino) && /* 0 for unlink */ 74177ddac94SWolfgang Denk (!strncmp((char *)jDir->name, name, len))) { /* a match */ 742998eaaecSwdenk if (jDir->version < version) { 743998eaaecSwdenk put_fl_mem(jDir); 7447205e407Swdenk continue; 745998eaaecSwdenk } 746fe8c2806Swdenk 7477205e407Swdenk if (jDir->version == version && inode != 0) { 7487205e407Swdenk /* I'm pretty sure this isn't legal */ 749fe8c2806Swdenk putstr(" ** ERROR ** "); 750fe8c2806Swdenk putnstr(jDir->name, jDir->nsize); 751fe8c2806Swdenk putLabeledWord(" has dup version =", version); 752fe8c2806Swdenk } 753fe8c2806Swdenk inode = jDir->ino; 754fe8c2806Swdenk version = jDir->version; 755fe8c2806Swdenk } 756fe8c2806Swdenk #if 0 757fe8c2806Swdenk putstr("\r\nfind_inode:p&l ->"); 758fe8c2806Swdenk putnstr(jDir->name, jDir->nsize); 759fe8c2806Swdenk putstr("\r\n"); 760fe8c2806Swdenk putLabeledWord("pino = ", jDir->pino); 761fe8c2806Swdenk putLabeledWord("nsize = ", jDir->nsize); 762fe8c2806Swdenk putLabeledWord("b = ", (u32) b); 763fe8c2806Swdenk putLabeledWord("counter = ", counter); 764fe8c2806Swdenk #endif 765998eaaecSwdenk put_fl_mem(jDir); 766fe8c2806Swdenk } 767fe8c2806Swdenk return inode; 768fe8c2806Swdenk } 769fe8c2806Swdenk 770180d3f74Swdenk char *mkmodestr(unsigned long mode, char *str) 771fe8c2806Swdenk { 772fe8c2806Swdenk static const char *l = "xwr"; 773fe8c2806Swdenk int mask = 1, i; 774fe8c2806Swdenk char c; 775fe8c2806Swdenk 776fe8c2806Swdenk switch (mode & S_IFMT) { 777fe8c2806Swdenk case S_IFDIR: str[0] = 'd'; break; 778fe8c2806Swdenk case S_IFBLK: str[0] = 'b'; break; 779fe8c2806Swdenk case S_IFCHR: str[0] = 'c'; break; 780fe8c2806Swdenk case S_IFIFO: str[0] = 'f'; break; 781fe8c2806Swdenk case S_IFLNK: str[0] = 'l'; break; 782fe8c2806Swdenk case S_IFSOCK: str[0] = 's'; break; 783fe8c2806Swdenk case S_IFREG: str[0] = '-'; break; 784fe8c2806Swdenk default: str[0] = '?'; 785fe8c2806Swdenk } 786fe8c2806Swdenk 787fe8c2806Swdenk for(i = 0; i < 9; i++) { 788fe8c2806Swdenk c = l[i%3]; 789fe8c2806Swdenk str[9-i] = (mode & mask)?c:'-'; 790fe8c2806Swdenk mask = mask<<1; 791fe8c2806Swdenk } 792fe8c2806Swdenk 793fe8c2806Swdenk if(mode & S_ISUID) str[3] = (mode & S_IXUSR)?'s':'S'; 794fe8c2806Swdenk if(mode & S_ISGID) str[6] = (mode & S_IXGRP)?'s':'S'; 795fe8c2806Swdenk if(mode & S_ISVTX) str[9] = (mode & S_IXOTH)?'t':'T'; 796fe8c2806Swdenk str[10] = '\0'; 797fe8c2806Swdenk return str; 798fe8c2806Swdenk } 799fe8c2806Swdenk 800fe8c2806Swdenk static inline void dump_stat(struct stat *st, const char *name) 801fe8c2806Swdenk { 802fe8c2806Swdenk char str[20]; 803fe8c2806Swdenk char s[64], *p; 804fe8c2806Swdenk 805fe8c2806Swdenk if (st->st_mtime == (time_t)(-1)) /* some ctimes really hate -1 */ 806fe8c2806Swdenk st->st_mtime = 1; 807fe8c2806Swdenk 80877ddac94SWolfgang Denk ctime_r((time_t *)&st->st_mtime, s/*,64*/); /* newlib ctime doesn't have buflen */ 809fe8c2806Swdenk 810fe8c2806Swdenk if ((p = strchr(s,'\n')) != NULL) *p = '\0'; 811fe8c2806Swdenk if ((p = strchr(s,'\r')) != NULL) *p = '\0'; 812fe8c2806Swdenk 813fe8c2806Swdenk /* 814fe8c2806Swdenk printf("%6lo %s %8ld %s %s\n", st->st_mode, mkmodestr(st->st_mode, str), 815fe8c2806Swdenk st->st_size, s, name); 816fe8c2806Swdenk */ 817fe8c2806Swdenk 818fe8c2806Swdenk printf(" %s %8ld %s %s", mkmodestr(st->st_mode,str), st->st_size, s, name); 819fe8c2806Swdenk } 820fe8c2806Swdenk 821fe8c2806Swdenk static inline u32 dump_inode(struct b_lists * pL, struct jffs2_raw_dirent *d, struct jffs2_raw_inode *i) 822fe8c2806Swdenk { 823fe8c2806Swdenk char fname[256]; 824fe8c2806Swdenk struct stat st; 825fe8c2806Swdenk 826fe8c2806Swdenk if(!d || !i) return -1; 827fe8c2806Swdenk 82877ddac94SWolfgang Denk strncpy(fname, (char *)d->name, d->nsize); 829fe8c2806Swdenk fname[d->nsize] = '\0'; 830fe8c2806Swdenk 831fe8c2806Swdenk memset(&st,0,sizeof(st)); 832fe8c2806Swdenk 833fe8c2806Swdenk st.st_mtime = i->mtime; 834fe8c2806Swdenk st.st_mode = i->mode; 835fe8c2806Swdenk st.st_ino = i->ino; 836fe8c2806Swdenk 837fe8c2806Swdenk /* neither dsize nor isize help us.. do it the long way */ 838fe8c2806Swdenk st.st_size = jffs2_1pass_read_inode(pL, i->ino, NULL); 839fe8c2806Swdenk 840fe8c2806Swdenk dump_stat(&st, fname); 841fe8c2806Swdenk 842fe8c2806Swdenk if (d->type == DT_LNK) { 843fe8c2806Swdenk unsigned char *src = (unsigned char *) (&i[1]); 844fe8c2806Swdenk putstr(" -> "); 845fe8c2806Swdenk putnstr(src, (int)i->dsize); 846fe8c2806Swdenk } 847fe8c2806Swdenk 848fe8c2806Swdenk putstr("\r\n"); 849fe8c2806Swdenk 850fe8c2806Swdenk return 0; 851fe8c2806Swdenk } 852fe8c2806Swdenk 853fe8c2806Swdenk /* list inodes with the given pino */ 854fe8c2806Swdenk static u32 855fe8c2806Swdenk jffs2_1pass_list_inodes(struct b_lists * pL, u32 pino) 856fe8c2806Swdenk { 857fe8c2806Swdenk struct b_node *b; 858fe8c2806Swdenk struct jffs2_raw_dirent *jDir; 859fe8c2806Swdenk 86006d01dbeSwdenk for (b = pL->dir.listHead; b; b = b->next) { 861998eaaecSwdenk jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 86206d01dbeSwdenk if ((pino == jDir->pino) && (jDir->ino)) { /* ino=0 -> unlink */ 863fe8c2806Swdenk u32 i_version = 0; 864998eaaecSwdenk struct jffs2_raw_inode ojNode; 865fe8c2806Swdenk struct jffs2_raw_inode *jNode, *i = NULL; 86606d01dbeSwdenk struct b_node *b2 = pL->frag.listHead; 867fe8c2806Swdenk 868fe8c2806Swdenk while (b2) { 869998eaaecSwdenk jNode = (struct jffs2_raw_inode *) 870998eaaecSwdenk get_fl_mem(b2->offset, sizeof(ojNode), &ojNode); 87132877d66Swdenk if (jNode->ino == jDir->ino && jNode->version >= i_version) { 87232877d66Swdenk if (i) 87332877d66Swdenk put_fl_mem(i); 874cf8bc577Swdenk 875cf8bc577Swdenk if (jDir->type == DT_LNK) 876cf8bc577Swdenk i = get_node_mem(b2->offset); 877cf8bc577Swdenk else 878998eaaecSwdenk i = get_fl_mem(b2->offset, sizeof(*i), NULL); 87932877d66Swdenk } 880fe8c2806Swdenk b2 = b2->next; 881fe8c2806Swdenk } 882fe8c2806Swdenk 883fe8c2806Swdenk dump_inode(pL, jDir, i); 884998eaaecSwdenk put_fl_mem(i); 885fe8c2806Swdenk } 886998eaaecSwdenk put_fl_mem(jDir); 887fe8c2806Swdenk } 888fe8c2806Swdenk return pino; 889fe8c2806Swdenk } 890fe8c2806Swdenk 891fe8c2806Swdenk static u32 892fe8c2806Swdenk jffs2_1pass_search_inode(struct b_lists * pL, const char *fname, u32 pino) 893fe8c2806Swdenk { 894fe8c2806Swdenk int i; 895fe8c2806Swdenk char tmp[256]; 896fe8c2806Swdenk char working_tmp[256]; 897fe8c2806Swdenk char *c; 898fe8c2806Swdenk 899fe8c2806Swdenk /* discard any leading slash */ 900fe8c2806Swdenk i = 0; 901fe8c2806Swdenk while (fname[i] == '/') 902fe8c2806Swdenk i++; 903fe8c2806Swdenk strcpy(tmp, &fname[i]); 904fe8c2806Swdenk 905fe8c2806Swdenk while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */ 906fe8c2806Swdenk { 907fe8c2806Swdenk strncpy(working_tmp, tmp, c - tmp); 908fe8c2806Swdenk working_tmp[c - tmp] = '\0'; 909fe8c2806Swdenk #if 0 910fe8c2806Swdenk putstr("search_inode: tmp = "); 911fe8c2806Swdenk putstr(tmp); 912fe8c2806Swdenk putstr("\r\n"); 913fe8c2806Swdenk putstr("search_inode: wtmp = "); 914fe8c2806Swdenk putstr(working_tmp); 915fe8c2806Swdenk putstr("\r\n"); 916fe8c2806Swdenk putstr("search_inode: c = "); 917fe8c2806Swdenk putstr(c); 918fe8c2806Swdenk putstr("\r\n"); 919fe8c2806Swdenk #endif 920fe8c2806Swdenk for (i = 0; i < strlen(c) - 1; i++) 921fe8c2806Swdenk tmp[i] = c[i + 1]; 922fe8c2806Swdenk tmp[i] = '\0'; 923fe8c2806Swdenk #if 0 924fe8c2806Swdenk putstr("search_inode: post tmp = "); 925fe8c2806Swdenk putstr(tmp); 926fe8c2806Swdenk putstr("\r\n"); 927fe8c2806Swdenk #endif 928fe8c2806Swdenk 929fe8c2806Swdenk if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino))) { 930fe8c2806Swdenk putstr("find_inode failed for name="); 931fe8c2806Swdenk putstr(working_tmp); 932fe8c2806Swdenk putstr("\r\n"); 933fe8c2806Swdenk return 0; 934fe8c2806Swdenk } 935fe8c2806Swdenk } 936fe8c2806Swdenk /* this is for the bare filename, directories have already been mapped */ 937fe8c2806Swdenk if (!(pino = jffs2_1pass_find_inode(pL, tmp, pino))) { 938fe8c2806Swdenk putstr("find_inode failed for name="); 939fe8c2806Swdenk putstr(tmp); 940fe8c2806Swdenk putstr("\r\n"); 941fe8c2806Swdenk return 0; 942fe8c2806Swdenk } 943fe8c2806Swdenk return pino; 944fe8c2806Swdenk 945fe8c2806Swdenk } 946fe8c2806Swdenk 947fe8c2806Swdenk static u32 948fe8c2806Swdenk jffs2_1pass_resolve_inode(struct b_lists * pL, u32 ino) 949fe8c2806Swdenk { 950fe8c2806Swdenk struct b_node *b; 951fe8c2806Swdenk struct b_node *b2; 952fe8c2806Swdenk struct jffs2_raw_dirent *jDir; 953fe8c2806Swdenk struct jffs2_raw_inode *jNode; 954998eaaecSwdenk u8 jDirFoundType = 0; 955998eaaecSwdenk u32 jDirFoundIno = 0; 956998eaaecSwdenk u32 jDirFoundPino = 0; 957fe8c2806Swdenk char tmp[256]; 958fe8c2806Swdenk u32 version = 0; 959fe8c2806Swdenk u32 pino; 960fe8c2806Swdenk unsigned char *src; 961fe8c2806Swdenk 962fe8c2806Swdenk /* we need to search all and return the inode with the highest version */ 96306d01dbeSwdenk for(b = pL->dir.listHead; b; b = b->next) { 964998eaaecSwdenk jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 965fe8c2806Swdenk if (ino == jDir->ino) { 966998eaaecSwdenk if (jDir->version < version) { 967998eaaecSwdenk put_fl_mem(jDir); 9687205e407Swdenk continue; 969998eaaecSwdenk } 970fe8c2806Swdenk 971998eaaecSwdenk if (jDir->version == version && jDirFoundType) { 9727205e407Swdenk /* I'm pretty sure this isn't legal */ 973fe8c2806Swdenk putstr(" ** ERROR ** "); 974fe8c2806Swdenk putnstr(jDir->name, jDir->nsize); 975fe8c2806Swdenk putLabeledWord(" has dup version (resolve) = ", 976fe8c2806Swdenk version); 977fe8c2806Swdenk } 978fe8c2806Swdenk 979998eaaecSwdenk jDirFoundType = jDir->type; 980998eaaecSwdenk jDirFoundIno = jDir->ino; 981998eaaecSwdenk jDirFoundPino = jDir->pino; 982fe8c2806Swdenk version = jDir->version; 983fe8c2806Swdenk } 984998eaaecSwdenk put_fl_mem(jDir); 985fe8c2806Swdenk } 986fe8c2806Swdenk /* now we found the right entry again. (shoulda returned inode*) */ 987998eaaecSwdenk if (jDirFoundType != DT_LNK) 988998eaaecSwdenk return jDirFoundIno; 98906d01dbeSwdenk 99006d01dbeSwdenk /* it's a soft link so we follow it again. */ 99106d01dbeSwdenk b2 = pL->frag.listHead; 992fe8c2806Swdenk while (b2) { 993998eaaecSwdenk jNode = (struct jffs2_raw_inode *) get_node_mem(b2->offset); 994998eaaecSwdenk if (jNode->ino == jDirFoundIno) { 9952729af9dSwdenk src = (unsigned char *)jNode + sizeof(struct jffs2_raw_inode); 996fe8c2806Swdenk 997fe8c2806Swdenk #if 0 998fe8c2806Swdenk putLabeledWord("\t\t dsize = ", jNode->dsize); 999fe8c2806Swdenk putstr("\t\t target = "); 1000fe8c2806Swdenk putnstr(src, jNode->dsize); 1001fe8c2806Swdenk putstr("\r\n"); 1002fe8c2806Swdenk #endif 100377ddac94SWolfgang Denk strncpy(tmp, (char *)src, jNode->dsize); 1004fe8c2806Swdenk tmp[jNode->dsize] = '\0'; 1005998eaaecSwdenk put_fl_mem(jNode); 1006fe8c2806Swdenk break; 1007fe8c2806Swdenk } 1008fe8c2806Swdenk b2 = b2->next; 1009998eaaecSwdenk put_fl_mem(jNode); 1010fe8c2806Swdenk } 1011fe8c2806Swdenk /* ok so the name of the new file to find is in tmp */ 1012fe8c2806Swdenk /* if it starts with a slash it is root based else shared dirs */ 1013fe8c2806Swdenk if (tmp[0] == '/') 1014fe8c2806Swdenk pino = 1; 1015fe8c2806Swdenk else 1016998eaaecSwdenk pino = jDirFoundPino; 1017fe8c2806Swdenk 1018fe8c2806Swdenk return jffs2_1pass_search_inode(pL, tmp, pino); 1019fe8c2806Swdenk } 1020fe8c2806Swdenk 1021fe8c2806Swdenk static u32 1022fe8c2806Swdenk jffs2_1pass_search_list_inodes(struct b_lists * pL, const char *fname, u32 pino) 1023fe8c2806Swdenk { 1024fe8c2806Swdenk int i; 1025fe8c2806Swdenk char tmp[256]; 1026fe8c2806Swdenk char working_tmp[256]; 1027fe8c2806Swdenk char *c; 1028fe8c2806Swdenk 1029fe8c2806Swdenk /* discard any leading slash */ 1030fe8c2806Swdenk i = 0; 1031fe8c2806Swdenk while (fname[i] == '/') 1032fe8c2806Swdenk i++; 1033fe8c2806Swdenk strcpy(tmp, &fname[i]); 1034fe8c2806Swdenk working_tmp[0] = '\0'; 1035fe8c2806Swdenk while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */ 1036fe8c2806Swdenk { 1037fe8c2806Swdenk strncpy(working_tmp, tmp, c - tmp); 1038fe8c2806Swdenk working_tmp[c - tmp] = '\0'; 1039fe8c2806Swdenk for (i = 0; i < strlen(c) - 1; i++) 1040fe8c2806Swdenk tmp[i] = c[i + 1]; 1041fe8c2806Swdenk tmp[i] = '\0'; 1042fe8c2806Swdenk /* only a failure if we arent looking at top level */ 104306d01dbeSwdenk if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino)) && 104406d01dbeSwdenk (working_tmp[0])) { 1045fe8c2806Swdenk putstr("find_inode failed for name="); 1046fe8c2806Swdenk putstr(working_tmp); 1047fe8c2806Swdenk putstr("\r\n"); 1048fe8c2806Swdenk return 0; 1049fe8c2806Swdenk } 1050fe8c2806Swdenk } 1051fe8c2806Swdenk 1052fe8c2806Swdenk if (tmp[0] && !(pino = jffs2_1pass_find_inode(pL, tmp, pino))) { 1053fe8c2806Swdenk putstr("find_inode failed for name="); 1054fe8c2806Swdenk putstr(tmp); 1055fe8c2806Swdenk putstr("\r\n"); 1056fe8c2806Swdenk return 0; 1057fe8c2806Swdenk } 1058fe8c2806Swdenk /* this is for the bare filename, directories have already been mapped */ 1059fe8c2806Swdenk if (!(pino = jffs2_1pass_list_inodes(pL, pino))) { 1060fe8c2806Swdenk putstr("find_inode failed for name="); 1061fe8c2806Swdenk putstr(tmp); 1062fe8c2806Swdenk putstr("\r\n"); 1063fe8c2806Swdenk return 0; 1064fe8c2806Swdenk } 1065fe8c2806Swdenk return pino; 1066fe8c2806Swdenk 1067fe8c2806Swdenk } 1068fe8c2806Swdenk 1069fe8c2806Swdenk unsigned char 1070fe8c2806Swdenk jffs2_1pass_rescan_needed(struct part_info *part) 1071fe8c2806Swdenk { 1072fe8c2806Swdenk struct b_node *b; 1073998eaaecSwdenk struct jffs2_unknown_node onode; 1074fe8c2806Swdenk struct jffs2_unknown_node *node; 1075fe8c2806Swdenk struct b_lists *pL = (struct b_lists *)part->jffs2_priv; 1076fe8c2806Swdenk 1077fe8c2806Swdenk if (part->jffs2_priv == 0){ 1078fe8c2806Swdenk DEBUGF ("rescan: First time in use\n"); 1079fe8c2806Swdenk return 1; 1080fe8c2806Swdenk } 1081700a0c64SWolfgang Denk 1082fe8c2806Swdenk /* if we have no list, we need to rescan */ 108306d01dbeSwdenk if (pL->frag.listCount == 0) { 1084fe8c2806Swdenk DEBUGF ("rescan: fraglist zero\n"); 1085fe8c2806Swdenk return 1; 1086fe8c2806Swdenk } 1087fe8c2806Swdenk 108806d01dbeSwdenk /* but suppose someone reflashed a partition at the same offset... */ 108906d01dbeSwdenk b = pL->dir.listHead; 1090fe8c2806Swdenk while (b) { 1091998eaaecSwdenk node = (struct jffs2_unknown_node *) get_fl_mem(b->offset, 1092998eaaecSwdenk sizeof(onode), &onode); 1093fe8c2806Swdenk if (node->nodetype != JFFS2_NODETYPE_DIRENT) { 109406d01dbeSwdenk DEBUGF ("rescan: fs changed beneath me? (%lx)\n", 109506d01dbeSwdenk (unsigned long) b->offset); 1096fe8c2806Swdenk return 1; 1097fe8c2806Swdenk } 1098fe8c2806Swdenk b = b->next; 1099fe8c2806Swdenk } 1100fe8c2806Swdenk return 0; 1101fe8c2806Swdenk } 1102fe8c2806Swdenk 110306d01dbeSwdenk #ifdef DEBUG_FRAGMENTS 110406d01dbeSwdenk static void 110506d01dbeSwdenk dump_fragments(struct b_lists *pL) 1106fe8c2806Swdenk { 1107fe8c2806Swdenk struct b_node *b; 1108998eaaecSwdenk struct jffs2_raw_inode ojNode; 1109fe8c2806Swdenk struct jffs2_raw_inode *jNode; 1110fe8c2806Swdenk 111106d01dbeSwdenk putstr("\r\n\r\n******The fragment Entries******\r\n"); 111206d01dbeSwdenk b = pL->frag.listHead; 111306d01dbeSwdenk while (b) { 1114998eaaecSwdenk jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 1115998eaaecSwdenk sizeof(ojNode), &ojNode); 111606d01dbeSwdenk putLabeledWord("\r\n\tbuild_list: FLASH_OFFSET = ", b->offset); 111706d01dbeSwdenk putLabeledWord("\tbuild_list: totlen = ", jNode->totlen); 111806d01dbeSwdenk putLabeledWord("\tbuild_list: inode = ", jNode->ino); 111906d01dbeSwdenk putLabeledWord("\tbuild_list: version = ", jNode->version); 112006d01dbeSwdenk putLabeledWord("\tbuild_list: isize = ", jNode->isize); 112106d01dbeSwdenk putLabeledWord("\tbuild_list: atime = ", jNode->atime); 112206d01dbeSwdenk putLabeledWord("\tbuild_list: offset = ", jNode->offset); 112306d01dbeSwdenk putLabeledWord("\tbuild_list: csize = ", jNode->csize); 112406d01dbeSwdenk putLabeledWord("\tbuild_list: dsize = ", jNode->dsize); 112506d01dbeSwdenk putLabeledWord("\tbuild_list: compr = ", jNode->compr); 112606d01dbeSwdenk putLabeledWord("\tbuild_list: usercompr = ", jNode->usercompr); 112706d01dbeSwdenk putLabeledWord("\tbuild_list: flags = ", jNode->flags); 11288bde7f77Swdenk putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */ 112906d01dbeSwdenk b = b->next; 113006d01dbeSwdenk } 113106d01dbeSwdenk } 113206d01dbeSwdenk #endif 113306d01dbeSwdenk 113406d01dbeSwdenk #ifdef DEBUG_DIRENTS 113506d01dbeSwdenk static void 113606d01dbeSwdenk dump_dirents(struct b_lists *pL) 113706d01dbeSwdenk { 113806d01dbeSwdenk struct b_node *b; 113906d01dbeSwdenk struct jffs2_raw_dirent *jDir; 114006d01dbeSwdenk 1141fe8c2806Swdenk putstr("\r\n\r\n******The directory Entries******\r\n"); 114206d01dbeSwdenk b = pL->dir.listHead; 1143fe8c2806Swdenk while (b) { 1144998eaaecSwdenk jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset); 1145fe8c2806Swdenk putstr("\r\n"); 1146fe8c2806Swdenk putnstr(jDir->name, jDir->nsize); 1147fe8c2806Swdenk putLabeledWord("\r\n\tbuild_list: magic = ", jDir->magic); 1148fe8c2806Swdenk putLabeledWord("\tbuild_list: nodetype = ", jDir->nodetype); 1149fe8c2806Swdenk putLabeledWord("\tbuild_list: hdr_crc = ", jDir->hdr_crc); 1150fe8c2806Swdenk putLabeledWord("\tbuild_list: pino = ", jDir->pino); 1151fe8c2806Swdenk putLabeledWord("\tbuild_list: version = ", jDir->version); 1152fe8c2806Swdenk putLabeledWord("\tbuild_list: ino = ", jDir->ino); 1153fe8c2806Swdenk putLabeledWord("\tbuild_list: mctime = ", jDir->mctime); 1154fe8c2806Swdenk putLabeledWord("\tbuild_list: nsize = ", jDir->nsize); 1155fe8c2806Swdenk putLabeledWord("\tbuild_list: type = ", jDir->type); 1156fe8c2806Swdenk putLabeledWord("\tbuild_list: node_crc = ", jDir->node_crc); 1157fe8c2806Swdenk putLabeledWord("\tbuild_list: name_crc = ", jDir->name_crc); 11588bde7f77Swdenk putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */ 1159fe8c2806Swdenk b = b->next; 1160998eaaecSwdenk put_fl_mem(jDir); 1161fe8c2806Swdenk } 1162fe8c2806Swdenk } 116306d01dbeSwdenk #endif 116406d01dbeSwdenk 116506d01dbeSwdenk static u32 116606d01dbeSwdenk jffs2_1pass_build_lists(struct part_info * part) 116706d01dbeSwdenk { 116806d01dbeSwdenk struct b_lists *pL; 116906d01dbeSwdenk struct jffs2_unknown_node *node; 117006d01dbeSwdenk u32 offset, oldoffset = 0; 117106d01dbeSwdenk u32 max = part->size - sizeof(struct jffs2_raw_inode); 117206d01dbeSwdenk u32 counter = 0; 117306d01dbeSwdenk u32 counter4 = 0; 117406d01dbeSwdenk u32 counterF = 0; 117506d01dbeSwdenk u32 counterN = 0; 117606d01dbeSwdenk 117706d01dbeSwdenk /* turn off the lcd. Refreshing the lcd adds 50% overhead to the */ 117806d01dbeSwdenk /* jffs2 list building enterprise nope. in newer versions the overhead is */ 117906d01dbeSwdenk /* only about 5 %. not enough to inconvenience people for. */ 118006d01dbeSwdenk /* lcd_off(); */ 118106d01dbeSwdenk 118206d01dbeSwdenk /* if we are building a list we need to refresh the cache. */ 118306d01dbeSwdenk jffs_init_1pass_list(part); 118406d01dbeSwdenk pL = (struct b_lists *)part->jffs2_priv; 118506d01dbeSwdenk offset = 0; 11864b9206edSwdenk puts ("Scanning JFFS2 FS: "); 118706d01dbeSwdenk 118806d01dbeSwdenk /* start at the beginning of the partition */ 118906d01dbeSwdenk while (offset < max) { 119006d01dbeSwdenk if ((oldoffset >> SPIN_BLKSIZE) != (offset >> SPIN_BLKSIZE)) { 119106d01dbeSwdenk printf("\b\b%c ", spinner[counter++ % sizeof(spinner)]); 119206d01dbeSwdenk oldoffset = offset; 1193fe8c2806Swdenk } 11940b8fa03bSwdenk 1195fc1cfcdbSwdenk node = (struct jffs2_unknown_node *) get_node_mem((u32)part->offset + offset); 1196fc1cfcdbSwdenk if (node->magic == JFFS2_MAGIC_BITMASK && hdr_crc(node)) { 1197fc1cfcdbSwdenk /* if its a fragment add it */ 1198fc1cfcdbSwdenk if (node->nodetype == JFFS2_NODETYPE_INODE && 119974f92e6aSWolfgang Denk inode_crc((struct jffs2_raw_inode *) node) && 120074f92e6aSWolfgang Denk data_crc((struct jffs2_raw_inode *) node)) { 120106d01dbeSwdenk if (insert_node(&pL->frag, (u32) part->offset + 1202998eaaecSwdenk offset) == NULL) { 1203998eaaecSwdenk put_fl_mem(node); 120406d01dbeSwdenk return 0; 1205998eaaecSwdenk } 120606d01dbeSwdenk } else if (node->nodetype == JFFS2_NODETYPE_DIRENT && 120706d01dbeSwdenk dirent_crc((struct jffs2_raw_dirent *) node) && 120806d01dbeSwdenk dirent_name_crc((struct jffs2_raw_dirent *) node)) { 1209fc1cfcdbSwdenk if (! (counterN%100)) 12104b9206edSwdenk puts ("\b\b. "); 121106d01dbeSwdenk if (insert_node(&pL->dir, (u32) part->offset + 1212998eaaecSwdenk offset) == NULL) { 1213998eaaecSwdenk put_fl_mem(node); 121406d01dbeSwdenk return 0; 1215998eaaecSwdenk } 121606d01dbeSwdenk counterN++; 121706d01dbeSwdenk } else if (node->nodetype == JFFS2_NODETYPE_CLEANMARKER) { 121806d01dbeSwdenk if (node->totlen != sizeof(struct jffs2_unknown_node)) 121906d01dbeSwdenk printf("OOPS Cleanmarker has bad size " 122006d01dbeSwdenk "%d != %d\n", node->totlen, 122106d01dbeSwdenk sizeof(struct jffs2_unknown_node)); 12227205e407Swdenk } else if (node->nodetype == JFFS2_NODETYPE_PADDING) { 12237205e407Swdenk if (node->totlen < sizeof(struct jffs2_unknown_node)) 12247205e407Swdenk printf("OOPS Padding has bad size " 12257205e407Swdenk "%d < %d\n", node->totlen, 12267205e407Swdenk sizeof(struct jffs2_unknown_node)); 122706d01dbeSwdenk } else { 1228fc1cfcdbSwdenk printf("Unknown node type: %x len %d " 1229fc1cfcdbSwdenk "offset 0x%x\n", node->nodetype, 1230fc1cfcdbSwdenk node->totlen, offset); 123106d01dbeSwdenk } 123206d01dbeSwdenk offset += ((node->totlen + 3) & ~3); 123306d01dbeSwdenk counterF++; 123406d01dbeSwdenk } else if (node->magic == JFFS2_EMPTY_BITMASK && 123506d01dbeSwdenk node->nodetype == JFFS2_EMPTY_BITMASK) { 123606d01dbeSwdenk offset = jffs2_scan_empty(offset, part); 123706d01dbeSwdenk } else { /* if we know nothing, we just step and look. */ 123806d01dbeSwdenk offset += 4; 123906d01dbeSwdenk counter4++; 124006d01dbeSwdenk } 124106d01dbeSwdenk /* printf("unknown node magic %4.4x %4.4x @ %lx\n", node->magic, node->nodetype, (unsigned long)node); */ 1242998eaaecSwdenk put_fl_mem(node); 124306d01dbeSwdenk } 124406d01dbeSwdenk 124506d01dbeSwdenk putstr("\b\b done.\r\n"); /* close off the dots */ 124606d01dbeSwdenk /* turn the lcd back on. */ 124706d01dbeSwdenk /* splash(); */ 124806d01dbeSwdenk 124906d01dbeSwdenk #if 0 125006d01dbeSwdenk putLabeledWord("dir entries = ", pL->dir.listCount); 125106d01dbeSwdenk putLabeledWord("frag entries = ", pL->frag.listCount); 125206d01dbeSwdenk putLabeledWord("+4 increments = ", counter4); 125306d01dbeSwdenk putLabeledWord("+file_offset increments = ", counterF); 125406d01dbeSwdenk 125506d01dbeSwdenk #endif 125606d01dbeSwdenk 125706d01dbeSwdenk #ifdef DEBUG_DIRENTS 125806d01dbeSwdenk dump_dirents(pL); 125906d01dbeSwdenk #endif 126006d01dbeSwdenk 126106d01dbeSwdenk #ifdef DEBUG_FRAGMENTS 126206d01dbeSwdenk dump_fragments(pL); 126306d01dbeSwdenk #endif 126406d01dbeSwdenk 1265fe8c2806Swdenk /* give visual feedback that we are done scanning the flash */ 1266fe8c2806Swdenk led_blink(0x0, 0x0, 0x1, 0x1); /* off, forever, on 100ms, off 100ms */ 1267fe8c2806Swdenk return 1; 1268fe8c2806Swdenk } 1269fe8c2806Swdenk 1270fe8c2806Swdenk 1271fe8c2806Swdenk static u32 1272fe8c2806Swdenk jffs2_1pass_fill_info(struct b_lists * pL, struct b_jffs2_info * piL) 1273fe8c2806Swdenk { 1274fe8c2806Swdenk struct b_node *b; 1275998eaaecSwdenk struct jffs2_raw_inode ojNode; 1276fe8c2806Swdenk struct jffs2_raw_inode *jNode; 1277fe8c2806Swdenk int i; 1278fe8c2806Swdenk 1279fe8c2806Swdenk for (i = 0; i < JFFS2_NUM_COMPR; i++) { 1280fe8c2806Swdenk piL->compr_info[i].num_frags = 0; 1281fe8c2806Swdenk piL->compr_info[i].compr_sum = 0; 1282fe8c2806Swdenk piL->compr_info[i].decompr_sum = 0; 1283fe8c2806Swdenk } 1284fe8c2806Swdenk 128506d01dbeSwdenk b = pL->frag.listHead; 1286fe8c2806Swdenk while (b) { 1287998eaaecSwdenk jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset, 1288998eaaecSwdenk sizeof(ojNode), &ojNode); 1289fe8c2806Swdenk if (jNode->compr < JFFS2_NUM_COMPR) { 1290fe8c2806Swdenk piL->compr_info[jNode->compr].num_frags++; 1291fe8c2806Swdenk piL->compr_info[jNode->compr].compr_sum += jNode->csize; 1292fe8c2806Swdenk piL->compr_info[jNode->compr].decompr_sum += jNode->dsize; 1293fe8c2806Swdenk } 1294fe8c2806Swdenk b = b->next; 1295fe8c2806Swdenk } 1296fe8c2806Swdenk return 0; 1297fe8c2806Swdenk } 1298fe8c2806Swdenk 1299fe8c2806Swdenk 1300fe8c2806Swdenk static struct b_lists * 1301fe8c2806Swdenk jffs2_get_list(struct part_info * part, const char *who) 1302fe8c2806Swdenk { 1303700a0c64SWolfgang Denk /* copy requested part_info struct pointer to global location */ 1304700a0c64SWolfgang Denk current_part = part; 1305700a0c64SWolfgang Denk 1306fe8c2806Swdenk if (jffs2_1pass_rescan_needed(part)) { 1307fe8c2806Swdenk if (!jffs2_1pass_build_lists(part)) { 1308fe8c2806Swdenk printf("%s: Failed to scan JFFSv2 file structure\n", who); 1309fe8c2806Swdenk return NULL; 1310fe8c2806Swdenk } 1311fe8c2806Swdenk } 1312fe8c2806Swdenk return (struct b_lists *)part->jffs2_priv; 1313fe8c2806Swdenk } 1314fe8c2806Swdenk 1315fe8c2806Swdenk 1316fe8c2806Swdenk /* Print directory / file contents */ 1317fe8c2806Swdenk u32 1318fe8c2806Swdenk jffs2_1pass_ls(struct part_info * part, const char *fname) 1319fe8c2806Swdenk { 1320fe8c2806Swdenk struct b_lists *pl; 132187b8bd5aSWolfgang Denk long ret = 1; 1322fe8c2806Swdenk u32 inode; 1323fe8c2806Swdenk 1324fe8c2806Swdenk if (! (pl = jffs2_get_list(part, "ls"))) 1325fe8c2806Swdenk return 0; 1326fe8c2806Swdenk 1327fe8c2806Swdenk if (! (inode = jffs2_1pass_search_list_inodes(pl, fname, 1))) { 1328fe8c2806Swdenk putstr("ls: Failed to scan jffs2 file structure\r\n"); 1329fe8c2806Swdenk return 0; 1330fe8c2806Swdenk } 1331fc1cfcdbSwdenk 1332fc1cfcdbSwdenk 1333fe8c2806Swdenk #if 0 1334fe8c2806Swdenk putLabeledWord("found file at inode = ", inode); 1335fe8c2806Swdenk putLabeledWord("read_inode returns = ", ret); 1336fe8c2806Swdenk #endif 1337fc1cfcdbSwdenk 1338fc1cfcdbSwdenk return ret; 1339fe8c2806Swdenk } 1340fe8c2806Swdenk 1341fe8c2806Swdenk 1342fe8c2806Swdenk /* Load a file from flash into memory. fname can be a full path */ 1343fe8c2806Swdenk u32 1344fe8c2806Swdenk jffs2_1pass_load(char *dest, struct part_info * part, const char *fname) 1345fe8c2806Swdenk { 1346fe8c2806Swdenk 1347fe8c2806Swdenk struct b_lists *pl; 134887b8bd5aSWolfgang Denk long ret = 1; 1349fe8c2806Swdenk u32 inode; 1350fe8c2806Swdenk 1351fe8c2806Swdenk if (! (pl = jffs2_get_list(part, "load"))) 1352fe8c2806Swdenk return 0; 1353fe8c2806Swdenk 1354fe8c2806Swdenk if (! (inode = jffs2_1pass_search_inode(pl, fname, 1))) { 1355fe8c2806Swdenk putstr("load: Failed to find inode\r\n"); 1356fe8c2806Swdenk return 0; 1357fe8c2806Swdenk } 1358fe8c2806Swdenk 1359fe8c2806Swdenk /* Resolve symlinks */ 1360fe8c2806Swdenk if (! (inode = jffs2_1pass_resolve_inode(pl, inode))) { 1361fe8c2806Swdenk putstr("load: Failed to resolve inode structure\r\n"); 1362fe8c2806Swdenk return 0; 1363fe8c2806Swdenk } 1364fe8c2806Swdenk 1365fe8c2806Swdenk if ((ret = jffs2_1pass_read_inode(pl, inode, dest)) < 0) { 1366fe8c2806Swdenk putstr("load: Failed to read inode\r\n"); 1367fe8c2806Swdenk return 0; 1368fe8c2806Swdenk } 1369fe8c2806Swdenk 1370fe8c2806Swdenk DEBUGF ("load: loaded '%s' to 0x%lx (%ld bytes)\n", fname, 1371fe8c2806Swdenk (unsigned long) dest, ret); 1372fe8c2806Swdenk return ret; 1373fe8c2806Swdenk } 1374fe8c2806Swdenk 1375fe8c2806Swdenk /* Return information about the fs on this partition */ 1376fe8c2806Swdenk u32 1377fe8c2806Swdenk jffs2_1pass_info(struct part_info * part) 1378fe8c2806Swdenk { 1379fe8c2806Swdenk struct b_jffs2_info info; 1380fe8c2806Swdenk struct b_lists *pl; 1381fe8c2806Swdenk int i; 1382fe8c2806Swdenk 1383fe8c2806Swdenk if (! (pl = jffs2_get_list(part, "info"))) 1384fe8c2806Swdenk return 0; 1385fe8c2806Swdenk 1386fe8c2806Swdenk jffs2_1pass_fill_info(pl, &info); 1387fe8c2806Swdenk for (i = 0; i < JFFS2_NUM_COMPR; i++) { 13884b9206edSwdenk printf ("Compression: %s\n" 13894b9206edSwdenk "\tfrag count: %d\n" 13904b9206edSwdenk "\tcompressed sum: %d\n" 13914b9206edSwdenk "\tuncompressed sum: %d\n", 13924b9206edSwdenk compr_names[i], 13934b9206edSwdenk info.compr_info[i].num_frags, 13944b9206edSwdenk info.compr_info[i].compr_sum, 13954b9206edSwdenk info.compr_info[i].decompr_sum); 1396fe8c2806Swdenk } 1397fe8c2806Swdenk return 1; 1398fe8c2806Swdenk } 1399fe8c2806Swdenk 1400fe8c2806Swdenk #endif /* CFG_CMD_JFFS2 */ 1401