fs/jffs2/jffs2_nand_1pass.c

   1 #include <common.h>
   2
   3 #if !defined(CFG_NAND_LEGACY) && defined(CONFIG_CMD_JFFS2)
   4
   5 #include <malloc.h>
   6 #include <linux/stat.h>
   7 #include <linux/time.h>
   8
   9 #include <jffs2/jffs2.h>
  10 #include <jffs2/jffs2_1pass.h>
  11 #include <nand.h>
  12
  13 #include "jffs2_nand_private.h"
  14
  15 #define NODE_CHUNK      1024    /* size of memory allocation chunk in b_nodes */
  16
  17 /* Debugging switches */
  18 #undef  DEBUG_DIRENTS           /* print directory entry list after scan */
  19 #undef  DEBUG_FRAGMENTS         /* print fragment list after scan */
  20 #undef  DEBUG                   /* enable debugging messages */
  21
  22 #ifdef  DEBUG
  23 # define DEBUGF(fmt,args...)    printf(fmt ,##args)
  24 #else
  25 # define DEBUGF(fmt,args...)
  26 #endif
  27
  28 static nand_info_t *nand;
  29
  30 /* Compression names */
  31 static char *compr_names[] = {
  32         "NONE",
  33         "ZERO",
  34         "RTIME",
  35         "RUBINMIPS",
  36         "COPY",
  37         "DYNRUBIN",
  38         "ZLIB",
  39 #if defined(CONFIG_JFFS2_LZO_LZARI)
  40         "LZO",
  41         "LZARI",
  42 #endif
  43 };
  44
  45 /* Spinning wheel */
  46 static char spinner[] = { '|', '/', '-', '\\' };
  47
  48 /* Memory management */
  49 struct mem_block {
  50         unsigned index;
  51         struct mem_block *next;
  52         char nodes[0];
  53 };
  54
  55 static void
  56 free_nodes(struct b_list *list)
  57 {
  58         while (list->listMemBase != NULL) {
  59                 struct mem_block *next = list->listMemBase->next;
  60                 free(list->listMemBase);
  61                 list->listMemBase = next;
  62         }
  63 }
  64
  65 static struct b_node *
  66 add_node(struct b_list *list, int size)
  67 {
  68         u32 index = 0;
  69         struct mem_block *memBase;
  70         struct b_node *b;
  71
  72         memBase = list->listMemBase;
  73         if (memBase != NULL)
  74                 index = memBase->index;
  75
  76         if (memBase == NULL || index >= NODE_CHUNK) {
  77                 /* we need more space before we continue */
  78                 memBase = mmalloc(sizeof(struct mem_block) + NODE_CHUNK * size);
  79                 if (memBase == NULL) {
  80                         putstr("add_node: malloc failed\n");
  81                         return NULL;
  82                 }
  83                 memBase->next = list->listMemBase;
  84                 index = 0;
  85         }
  86         /* now we have room to add it. */
  87         b = (struct b_node *)&memBase->nodes[size * index];
  88         index ++;
  89
  90         memBase->index = index;
  91         list->listMemBase = memBase;
  92         list->listCount++;
  93         return b;
  94 }
  95
  96 static struct b_node *
  97 insert_node(struct b_list *list, struct b_node *new)
  98 {
  99 #ifdef CFG_JFFS2_SORT_FRAGMENTS
 100         struct b_node *b, *prev;
 101
 102         if (list->listTail != NULL && list->listCompare(new, list->listTail))
 103                 prev = list->listTail;
 104         else if (list->listLast != NULL && list->listCompare(new, list->listLast))
 105                 prev = list->listLast;
 106         else
 107                 prev = NULL;
 108
 109         for (b = (prev ? prev->next : list->listHead);
 110              b != NULL && list->listCompare(new, b);
 111              prev = b, b = b->next) {
 112                 list->listLoops++;
 113         }
 114         if (b != NULL)
 115                 list->listLast = prev;
 116
 117         if (b != NULL) {
 118                 new->next = b;
 119                 if (prev != NULL)
 120                         prev->next = new;
 121                 else
 122                         list->listHead = new;
 123         } else
 124 #endif
 125         {
 126                 new->next = (struct b_node *) NULL;
 127                 if (list->listTail != NULL) {
 128                         list->listTail->next = new;
 129                         list->listTail = new;
 130                 } else {
 131                         list->listTail = list->listHead = new;
 132                 }
 133         }
 134
 135         return new;
 136 }
 137
 138 static struct b_node *
 139 insert_inode(struct b_list *list, struct jffs2_raw_inode *node, u32 offset)
 140 {
 141         struct b_inode *new;
 142
 143         if (!(new = (struct b_inode *)add_node(list, sizeof(struct b_inode)))) {
 144                 putstr("add_node failed!\r\n");
 145                 return NULL;
 146         }
 147         new->offset = offset;
 148         new->version = node->version;
 149         new->ino = node->ino;
 150         new->isize = node->isize;
 151         new->csize = node->csize;
 152
 153         return insert_node(list, (struct b_node *)new);
 154 }
 155
 156 static struct b_node *
 157 insert_dirent(struct b_list *list, struct jffs2_raw_dirent *node, u32 offset)
 158 {
 159         struct b_dirent *new;
 160
 161         if (!(new = (struct b_dirent *)add_node(list, sizeof(struct b_dirent)))) {
 162                 putstr("add_node failed!\r\n");
 163                 return NULL;
 164         }
 165         new->offset = offset;
 166         new->version = node->version;
 167         new->pino = node->pino;
 168         new->ino = node->ino;
 169         new->nhash = full_name_hash(node->name, node->nsize);
 170         new->nsize = node->nsize;
 171         new->type = node->type;
 172
 173         return insert_node(list, (struct b_node *)new);
 174 }
 175
 176 #ifdef CFG_JFFS2_SORT_FRAGMENTS
 177 /* Sort data entries with the latest version last, so that if there
 178  * is overlapping data the latest version will be used.
 179  */
 180 static int compare_inodes(struct b_node *new, struct b_node *old)
 181 {
 182         struct jffs2_raw_inode ojNew;
 183         struct jffs2_raw_inode ojOld;
 184         struct jffs2_raw_inode *jNew =
 185                 (struct jffs2_raw_inode *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew);
 186         struct jffs2_raw_inode *jOld =
 187                 (struct jffs2_raw_inode *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld);
 188
 189         return jNew->version > jOld->version;
 190 }
 191
 192 /* Sort directory entries so all entries in the same directory
 193  * with the same name are grouped together, with the latest version
 194  * last. This makes it easy to eliminate all but the latest version
 195  * by marking the previous version dead by setting the inode to 0.
 196  */
 197 static int compare_dirents(struct b_node *new, struct b_node *old)
 198 {
 199         struct jffs2_raw_dirent ojNew;
 200         struct jffs2_raw_dirent ojOld;
 201         struct jffs2_raw_dirent *jNew =
 202                 (struct jffs2_raw_dirent *)get_fl_mem(new->offset, sizeof(ojNew), &ojNew);
 203         struct jffs2_raw_dirent *jOld =
 204                 (struct jffs2_raw_dirent *)get_fl_mem(old->offset, sizeof(ojOld), &ojOld);
 205         int cmp;
 206
 207         /* ascending sort by pino */
 208         if (jNew->pino != jOld->pino)
 209                 return jNew->pino > jOld->pino;
 210
 211         /* pino is the same, so use ascending sort by nsize, so
 212          * we don't do strncmp unless we really must.
 213          */
 214         if (jNew->nsize != jOld->nsize)
 215                 return jNew->nsize > jOld->nsize;
 216
 217         /* length is also the same, so use ascending sort by name
 218          */
 219         cmp = strncmp(jNew->name, jOld->name, jNew->nsize);
 220         if (cmp != 0)
 221                 return cmp > 0;
 222
 223         /* we have duplicate names in this directory, so use ascending
 224          * sort by version
 225          */
 226         if (jNew->version > jOld->version) {
 227                 /* since jNew is newer, we know jOld is not valid, so
 228                  * mark it with inode 0 and it will not be used
 229                  */
 230                 jOld->ino = 0;
 231                 return 1;
 232         }
 233
 234         return 0;
 235 }
 236 #endif
 237
 238 static u32
 239 jffs_init_1pass_list(struct part_info *part)
 240 {
 241         struct b_lists *pL;
 242
 243         if (part->jffs2_priv != NULL) {
 244                 pL = (struct b_lists *)part->jffs2_priv;
 245                 free_nodes(&pL->frag);
 246                 free_nodes(&pL->dir);
 247                 free(pL);
 248         }
 249         if (NULL != (part->jffs2_priv = malloc(sizeof(struct b_lists)))) {
 250                 pL = (struct b_lists *)part->jffs2_priv;
 251
 252                 memset(pL, 0, sizeof(*pL));
 253 #ifdef CFG_JFFS2_SORT_FRAGMENTS
 254                 pL->dir.listCompare = compare_dirents;
 255                 pL->frag.listCompare = compare_inodes;
 256 #endif
 257         }
 258         return 0;
 259 }
 260
 261 /* find the inode from the slashless name given a parent */
 262 static long
 263 jffs2_1pass_read_inode(struct b_lists *pL, u32 ino, char *dest,
 264                        struct stat *stat)
 265 {
 266         struct b_inode *jNode;
 267         u32 totalSize = 0;
 268         u32 latestVersion = 0;
 269         long ret;
 270
 271 #ifdef CFG_JFFS2_SORT_FRAGMENTS
 272         /* Find file size before loading any data, so fragments that
 273          * start past the end of file can be ignored. A fragment
 274          * that is partially in the file is loaded, so extra data may
 275          * be loaded up to the next 4K boundary above the file size.
 276          * This shouldn't cause trouble when loading kernel images, so
 277          * we will live with it.
 278          */
 279         for (jNode = (struct b_inode *)pL->frag.listHead; jNode; jNode = jNode->next) {
 280                 if ((ino == jNode->ino)) {
 281                         /* get actual file length from the newest node */
 282                         if (jNode->version >= latestVersion) {
 283                                 totalSize = jNode->isize;
 284                                 latestVersion = jNode->version;
 285                         }
 286                 }
 287         }
 288 #endif
 289
 290         for (jNode = (struct b_inode *)pL->frag.listHead; jNode; jNode = jNode->next) {
 291                 if ((ino != jNode->ino))
 292                         continue;
 293 #ifndef CFG_JFFS2_SORT_FRAGMENTS
 294                 /* get actual file length from the newest node */
 295                 if (jNode->version >= latestVersion) {
 296                         totalSize = jNode->isize;
 297                         latestVersion = jNode->version;
 298                 }
 299 #endif
 300                 if (dest || stat) {
 301                         char *src, *dst;
 302                         char data[4096 + sizeof(struct jffs2_raw_inode)];
 303                         struct jffs2_raw_inode *inode;
 304                         size_t len;
 305
 306                         inode = (struct jffs2_raw_inode *)&data;
 307                         len = sizeof(struct jffs2_raw_inode);
 308                         if (dest)
 309                                 len += jNode->csize;
 310                         nand_read(nand, jNode->offset, &len, inode);
 311                         /* ignore data behind latest known EOF */
 312                         if (inode->offset > totalSize)
 313                                 continue;
 314
 315                         if (stat) {
 316                                 stat->st_mtime = inode->mtime;
 317                                 stat->st_mode = inode->mode;
 318                                 stat->st_ino = inode->ino;
 319                                 stat->st_size = totalSize;
 320                         }
 321
 322                         if (!dest)
 323                                 continue;
 324
 325                         src = ((char *) inode) + sizeof(struct jffs2_raw_inode);
 326                         dst = (char *) (dest + inode->offset);
 327
 328                         switch (inode->compr) {
 329                         case JFFS2_COMPR_NONE:
 330                                 ret = 0;
 331                                 memcpy(dst, src, inode->dsize);
 332                                 break;
 333                         case JFFS2_COMPR_ZERO:
 334                                 ret = 0;
 335                                 memset(dst, 0, inode->dsize);
 336                                 break;
 337                         case JFFS2_COMPR_RTIME:
 338                                 ret = 0;
 339                                 rtime_decompress(src, dst, inode->csize, inode->dsize);
 340                                 break;
 341                         case JFFS2_COMPR_DYNRUBIN:
 342                                 /* this is slow but it works */
 343                                 ret = 0;
 344                                 dynrubin_decompress(src, dst, inode->csize, inode->dsize);
 345                                 break;
 346                         case JFFS2_COMPR_ZLIB:
 347                                 ret = zlib_decompress(src, dst, inode->csize, inode->dsize);
 348                                 break;
 349 #if defined(CONFIG_JFFS2_LZO_LZARI)
 350                         case JFFS2_COMPR_LZO:
 351                                 ret = lzo_decompress(src, dst, inode->csize, inode->dsize);
 352                                 break;
 353                         case JFFS2_COMPR_LZARI:
 354                                 ret = lzari_decompress(src, dst, inode->csize, inode->dsize);
 355                                 break;
 356 #endif
 357                         default:
 358                                 /* unknown */
 359                                 putLabeledWord("UNKOWN COMPRESSION METHOD = ", inode->compr);
 360                                 return -1;
 361                         }
 362                 }
 363         }
 364
 365         return totalSize;
 366 }
 367
 368 /* find the inode from the slashless name given a parent */
 369 static u32
 370 jffs2_1pass_find_inode(struct b_lists * pL, const char *name, u32 pino)
 371 {
 372         struct b_dirent *jDir;
 373         int len = strlen(name); /* name is assumed slash free */
 374         unsigned int nhash = full_name_hash(name, len);
 375         u32 version = 0;
 376         u32 inode = 0;
 377
 378         /* we need to search all and return the inode with the highest version */
 379         for (jDir = (struct b_dirent *)pL->dir.listHead; jDir; jDir = jDir->next) {
 380                 if ((pino == jDir->pino) && (jDir->ino) &&      /* 0 for unlink */
 381                     (len == jDir->nsize) && (nhash == jDir->nhash)) {
 382                         /* TODO: compare name */
 383                         if (jDir->version < version)
 384                                 continue;
 385
 386                         if (jDir->version == version && inode != 0) {
 387                                 /* I'm pretty sure this isn't legal */
 388                                 putstr(" ** ERROR ** ");
 389 /*                              putnstr(jDir->name, jDir->nsize); */
 390 /*                              putLabeledWord(" has dup version =", version); */
 391                         }
 392                         inode = jDir->ino;
 393                         version = jDir->version;
 394                 }
 395         }
 396         return inode;
 397 }
 398
 399 char *mkmodestr(unsigned long mode, char *str)
 400 {
 401         static const char *l = "xwr";
 402         int mask = 1, i;
 403         char c;
 404
 405         switch (mode & S_IFMT) {
 406                 case S_IFDIR:    str[0] = 'd'; break;
 407                 case S_IFBLK:    str[0] = 'b'; break;
 408                 case S_IFCHR:    str[0] = 'c'; break;
 409                 case S_IFIFO:    str[0] = 'f'; break;
 410                 case S_IFLNK:    str[0] = 'l'; break;
 411                 case S_IFSOCK:   str[0] = 's'; break;
 412                 case S_IFREG:    str[0] = '-'; break;
 413                 default:         str[0] = '?';
 414         }
 415
 416         for(i = 0; i < 9; i++) {
 417                 c = l[i%3];
 418                 str[9-i] = (mode & mask)?c:'-';
 419                 mask = mask<<1;
 420         }
 421
 422         if(mode & S_ISUID) str[3] = (mode & S_IXUSR)?'s':'S';
 423         if(mode & S_ISGID) str[6] = (mode & S_IXGRP)?'s':'S';
 424         if(mode & S_ISVTX) str[9] = (mode & S_IXOTH)?'t':'T';
 425         str[10] = '\0';
 426         return str;
 427 }
 428
 429 static inline void dump_stat(struct stat *st, const char *name)
 430 {
 431         char str[20];
 432         char s[64], *p;
 433
 434         if (st->st_mtime == (time_t)(-1)) /* some ctimes really hate -1 */
 435                 st->st_mtime = 1;
 436
 437         ctime_r(&st->st_mtime, s/*,64*/); /* newlib ctime doesn't have buflen */
 438
 439         if ((p = strchr(s,'\n')) != NULL) *p = '\0';
 440         if ((p = strchr(s,'\r')) != NULL) *p = '\0';
 441
 442 /*
 443         printf("%6lo %s %8ld %s %s\n", st->st_mode, mkmodestr(st->st_mode, str),
 444                 st->st_size, s, name);
 445 */
 446
 447         printf(" %s %8ld %s %s", mkmodestr(st->st_mode,str), st->st_size, s, name);
 448 }
 449
 450 static inline int
 451 dump_inode(struct b_lists *pL, struct b_dirent *d, struct b_inode *i)
 452 {
 453         char fname[JFFS2_MAX_NAME_LEN + 1];
 454         struct stat st;
 455         size_t len;
 456
 457         if(!d || !i) return -1;
 458         len = d->nsize;
 459         nand_read(nand, d->offset + sizeof(struct jffs2_raw_dirent),
 460                   &len, &fname);
 461         fname[d->nsize] = '\0';
 462
 463         memset(&st, 0, sizeof(st));
 464
 465         jffs2_1pass_read_inode(pL, i->ino, NULL, &st);
 466
 467         dump_stat(&st, fname);
 468 /* FIXME
 469         if (d->type == DT_LNK) {
 470                 unsigned char *src = (unsigned char *) (&i[1]);
 471                 putstr(" -> ");
 472                 putnstr(src, (int)i->dsize);
 473         }
 474 */
 475         putstr("\r\n");
 476
 477         return 0;
 478 }
 479
 480 /* list inodes with the given pino */
 481 static u32
 482 jffs2_1pass_list_inodes(struct b_lists * pL, u32 pino)
 483 {
 484         struct b_dirent *jDir;
 485         u32 i_version = 0;
 486
 487         for (jDir = (struct b_dirent *)pL->dir.listHead; jDir; jDir = jDir->next) {
 488                 if ((pino == jDir->pino) && (jDir->ino)) { /* ino=0 -> unlink */
 489                         struct b_inode *jNode = (struct b_inode *)pL->frag.listHead;
 490                         struct b_inode *i = NULL;
 491
 492                         while (jNode) {
 493                                 if (jNode->ino == jDir->ino && jNode->version >= i_version) {
 494                                         i_version = jNode->version;
 495                                         i = jNode;
 496                                 }
 497                                 jNode = jNode->next;
 498                         }
 499                         dump_inode(pL, jDir, i);
 500                 }
 501         }
 502         return pino;
 503 }
 504
 505 static u32
 506 jffs2_1pass_search_inode(struct b_lists * pL, const char *fname, u32 pino)
 507 {
 508         int i;
 509         char tmp[256];
 510         char working_tmp[256];
 511         char *c;
 512
 513         /* discard any leading slash */
 514         i = 0;
 515         while (fname[i] == '/')
 516                 i++;
 517         strcpy(tmp, &fname[i]);
 518
 519         while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */
 520         {
 521                 strncpy(working_tmp, tmp, c - tmp);
 522                 working_tmp[c - tmp] = '\0';
 523 #if 0
 524                 putstr("search_inode: tmp = ");
 525                 putstr(tmp);
 526                 putstr("\r\n");
 527                 putstr("search_inode: wtmp = ");
 528                 putstr(working_tmp);
 529                 putstr("\r\n");
 530                 putstr("search_inode: c = ");
 531                 putstr(c);
 532                 putstr("\r\n");
 533 #endif
 534                 for (i = 0; i < strlen(c) - 1; i++)
 535                         tmp[i] = c[i + 1];
 536                 tmp[i] = '\0';
 537 #if 0
 538                 putstr("search_inode: post tmp = ");
 539                 putstr(tmp);
 540                 putstr("\r\n");
 541 #endif
 542
 543                 if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino))) {
 544                         putstr("find_inode failed for name=");
 545                         putstr(working_tmp);
 546                         putstr("\r\n");
 547                         return 0;
 548                 }
 549         }
 550         /* this is for the bare filename, directories have already been mapped */
 551         if (!(pino = jffs2_1pass_find_inode(pL, tmp, pino))) {
 552                 putstr("find_inode failed for name=");
 553                 putstr(tmp);
 554                 putstr("\r\n");
 555                 return 0;
 556         }
 557         return pino;
 558
 559 }
 560
 561 static u32
 562 jffs2_1pass_resolve_inode(struct b_lists * pL, u32 ino)
 563 {
 564         struct b_dirent *jDir;
 565         struct b_inode *jNode;
 566         u8 jDirFoundType = 0;
 567         u32 jDirFoundIno = 0;
 568         u32 jDirFoundPino = 0;
 569         char tmp[JFFS2_MAX_NAME_LEN + 1];
 570         u32 version = 0;
 571         u32 pino;
 572
 573         /* we need to search all and return the inode with the highest version */
 574         for (jDir = (struct b_dirent *)pL->dir.listHead; jDir; jDir = jDir->next) {
 575                 if (ino == jDir->ino) {
 576                         if (jDir->version < version)
 577                                 continue;
 578
 579                         if (jDir->version == version && jDirFoundType) {
 580                                 /* I'm pretty sure this isn't legal */
 581                                 putstr(" ** ERROR ** ");
 582 /*                              putnstr(jDir->name, jDir->nsize); */
 583 /*                              putLabeledWord(" has dup version (resolve) = ", */
 584 /*                                      version); */
 585                         }
 586
 587                         jDirFoundType = jDir->type;
 588                         jDirFoundIno = jDir->ino;
 589                         jDirFoundPino = jDir->pino;
 590                         version = jDir->version;
 591                 }
 592         }
 593         /* now we found the right entry again. (shoulda returned inode*) */
 594         if (jDirFoundType != DT_LNK)
 595                 return jDirFoundIno;
 596
 597         /* it's a soft link so we follow it again. */
 598         for (jNode = (struct b_inode *)pL->frag.listHead; jNode; jNode = jNode->next) {
 599                 if (jNode->ino == jDirFoundIno) {
 600                         size_t len = jNode->csize;
 601                         nand_read(nand, jNode->offset + sizeof(struct jffs2_raw_inode), &len, &tmp);
 602                         tmp[jNode->csize] = '\0';
 603                         break;
 604                 }
 605         }
 606         /* ok so the name of the new file to find is in tmp */
 607         /* if it starts with a slash it is root based else shared dirs */
 608         if (tmp[0] == '/')
 609                 pino = 1;
 610         else
 611                 pino = jDirFoundPino;
 612
 613         return jffs2_1pass_search_inode(pL, tmp, pino);
 614 }
 615
 616 static u32
 617 jffs2_1pass_search_list_inodes(struct b_lists * pL, const char *fname, u32 pino)
 618 {
 619         int i;
 620         char tmp[256];
 621         char working_tmp[256];
 622         char *c;
 623
 624         /* discard any leading slash */
 625         i = 0;
 626         while (fname[i] == '/')
 627                 i++;
 628         strcpy(tmp, &fname[i]);
 629         working_tmp[0] = '\0';
 630         while ((c = (char *) strchr(tmp, '/'))) /* we are still dired searching */
 631         {
 632                 strncpy(working_tmp, tmp, c - tmp);
 633                 working_tmp[c - tmp] = '\0';
 634                 for (i = 0; i < strlen(c) - 1; i++)
 635                         tmp[i] = c[i + 1];
 636                 tmp[i] = '\0';
 637                 /* only a failure if we arent looking at top level */
 638                 if (!(pino = jffs2_1pass_find_inode(pL, working_tmp, pino)) &&
 639                     (working_tmp[0])) {
 640                         putstr("find_inode failed for name=");
 641                         putstr(working_tmp);
 642                         putstr("\r\n");
 643                         return 0;
 644                 }
 645         }
 646
 647         if (tmp[0] && !(pino = jffs2_1pass_find_inode(pL, tmp, pino))) {
 648                 putstr("find_inode failed for name=");
 649                 putstr(tmp);
 650                 putstr("\r\n");
 651                 return 0;
 652         }
 653         /* this is for the bare filename, directories have already been mapped */
 654         if (!(pino = jffs2_1pass_list_inodes(pL, pino))) {
 655                 putstr("find_inode failed for name=");
 656                 putstr(tmp);
 657                 putstr("\r\n");
 658                 return 0;
 659         }
 660         return pino;
 661
 662 }
 663
 664 unsigned char
 665 jffs2_1pass_rescan_needed(struct part_info *part)
 666 {
 667         struct b_node *b;
 668         struct jffs2_unknown_node onode;
 669         struct jffs2_unknown_node *node;
 670         struct b_lists *pL = (struct b_lists *)part->jffs2_priv;
 671
 672         if (part->jffs2_priv == 0){
 673                 DEBUGF ("rescan: First time in use\n");
 674                 return 1;
 675         }
 676         /* if we have no list, we need to rescan */
 677         if (pL->frag.listCount == 0) {
 678                 DEBUGF ("rescan: fraglist zero\n");
 679                 return 1;
 680         }
 681
 682         /* or if we are scanning a new partition */
 683         if (pL->partOffset != part->offset) {
 684                 DEBUGF ("rescan: different partition\n");
 685                 return 1;
 686         }
 687
 688         /* FIXME */
 689 #if 0
 690         /* but suppose someone reflashed a partition at the same offset... */
 691         b = pL->dir.listHead;
 692         while (b) {
 693                 node = (struct jffs2_unknown_node *) get_fl_mem(b->offset,
 694                         sizeof(onode), &onode);
 695                 if (node->nodetype != JFFS2_NODETYPE_DIRENT) {
 696                         DEBUGF ("rescan: fs changed beneath me? (%lx)\n",
 697                                         (unsigned long) b->offset);
 698                         return 1;
 699                 }
 700                 b = b->next;
 701         }
 702 #endif
 703         return 0;
 704 }
 705
 706 #ifdef DEBUG_FRAGMENTS
 707 static void
 708 dump_fragments(struct b_lists *pL)
 709 {
 710         struct b_node *b;
 711         struct jffs2_raw_inode ojNode;
 712         struct jffs2_raw_inode *jNode;
 713
 714         putstr("\r\n\r\n******The fragment Entries******\r\n");
 715         b = pL->frag.listHead;
 716         while (b) {
 717                 jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset,
 718                         sizeof(ojNode), &ojNode);
 719                 putLabeledWord("\r\n\tbuild_list: FLASH_OFFSET = ", b->offset);
 720                 putLabeledWord("\tbuild_list: totlen = ", jNode->totlen);
 721                 putLabeledWord("\tbuild_list: inode = ", jNode->ino);
 722                 putLabeledWord("\tbuild_list: version = ", jNode->version);
 723                 putLabeledWord("\tbuild_list: isize = ", jNode->isize);
 724                 putLabeledWord("\tbuild_list: atime = ", jNode->atime);
 725                 putLabeledWord("\tbuild_list: offset = ", jNode->offset);
 726                 putLabeledWord("\tbuild_list: csize = ", jNode->csize);
 727                 putLabeledWord("\tbuild_list: dsize = ", jNode->dsize);
 728                 putLabeledWord("\tbuild_list: compr = ", jNode->compr);
 729                 putLabeledWord("\tbuild_list: usercompr = ", jNode->usercompr);
 730                 putLabeledWord("\tbuild_list: flags = ", jNode->flags);
 731                 putLabeledWord("\tbuild_list: offset = ", b->offset);   /* FIXME: ? [RS] */
 732                 b = b->next;
 733         }
 734 }
 735 #endif
 736
 737 #ifdef DEBUG_DIRENTS
 738 static void
 739 dump_dirents(struct b_lists *pL)
 740 {
 741         struct b_node *b;
 742         struct jffs2_raw_dirent *jDir;
 743
 744         putstr("\r\n\r\n******The directory Entries******\r\n");
 745         b = pL->dir.listHead;
 746         while (b) {
 747                 jDir = (struct jffs2_raw_dirent *) get_node_mem(b->offset);
 748                 putstr("\r\n");
 749                 putnstr(jDir->name, jDir->nsize);
 750                 putLabeledWord("\r\n\tbuild_list: magic = ", jDir->magic);
 751                 putLabeledWord("\tbuild_list: nodetype = ", jDir->nodetype);
 752                 putLabeledWord("\tbuild_list: hdr_crc = ", jDir->hdr_crc);
 753                 putLabeledWord("\tbuild_list: pino = ", jDir->pino);
 754                 putLabeledWord("\tbuild_list: version = ", jDir->version);
 755                 putLabeledWord("\tbuild_list: ino = ", jDir->ino);
 756                 putLabeledWord("\tbuild_list: mctime = ", jDir->mctime);
 757                 putLabeledWord("\tbuild_list: nsize = ", jDir->nsize);
 758                 putLabeledWord("\tbuild_list: type = ", jDir->type);
 759                 putLabeledWord("\tbuild_list: node_crc = ", jDir->node_crc);
 760                 putLabeledWord("\tbuild_list: name_crc = ", jDir->name_crc);
 761                 putLabeledWord("\tbuild_list: offset = ", b->offset);   /* FIXME: ? [RS] */
 762                 b = b->next;
 763                 put_fl_mem(jDir);
 764         }
 765 }
 766 #endif
 767
 768 static int
 769 jffs2_fill_scan_buf(nand_info_t *nand, unsigned char *buf,
 770                     unsigned ofs, unsigned len)
 771 {
 772         int ret;
 773         unsigned olen;
 774
 775         olen = len;
 776         ret = nand_read(nand, ofs, &olen, buf);
 777         if (ret) {
 778                 printf("nand_read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret);
 779                 return ret;
 780         }
 781         if (olen < len) {
 782                 printf("Read at 0x%x gave only 0x%x bytes\n", ofs, olen);
 783                 return -1;
 784         }
 785         return 0;
 786 }
 787
 788 #define EMPTY_SCAN_SIZE 1024
 789 static u32
 790 jffs2_1pass_build_lists(struct part_info * part)
 791 {
 792         struct b_lists *pL;
 793         struct jffs2_unknown_node *node;
 794         unsigned nr_blocks, sectorsize, ofs, offset;
 795         char *buf;
 796         int i;
 797         u32 counter = 0;
 798         u32 counter4 = 0;
 799         u32 counterF = 0;
 800         u32 counterN = 0;
 801
 802         struct mtdids *id = part->dev->id;
 803         nand = nand_info + id->num;
 804
 805         /* if we are building a list we need to refresh the cache. */
 806         jffs_init_1pass_list(part);
 807         pL = (struct b_lists *)part->jffs2_priv;
 808         pL->partOffset = part->offset;
 809         puts ("Scanning JFFS2 FS:   ");
 810
 811         sectorsize = nand->erasesize;
 812         nr_blocks = part->size / sectorsize;
 813         buf = malloc(sectorsize);
 814         if (!buf)
 815                 return 0;
 816
 817         for (i = 0; i < nr_blocks; i++) {
 818                 printf("\b\b%c ", spinner[counter++ % sizeof(spinner)]);
 819
 820                 offset = part->offset + i * sectorsize;
 821
 822                 if (nand_block_isbad(nand, offset))
 823                         continue;
 824
 825                 if (jffs2_fill_scan_buf(nand, buf, offset, EMPTY_SCAN_SIZE))
 826                         return 0;
 827
 828                 ofs = 0;
 829                 /* Scan only 4KiB of 0xFF before declaring it's empty */
 830                 while (ofs < EMPTY_SCAN_SIZE && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
 831                         ofs += 4;
 832                 if (ofs == EMPTY_SCAN_SIZE)
 833                         continue;
 834
 835                 if (jffs2_fill_scan_buf(nand, buf + EMPTY_SCAN_SIZE, offset + EMPTY_SCAN_SIZE, sectorsize - EMPTY_SCAN_SIZE))
 836                         return 0;
 837                 offset += ofs;
 838
 839                 while (ofs < sectorsize - sizeof(struct jffs2_unknown_node)) {
 840                         node = (struct jffs2_unknown_node *)&buf[ofs];
 841                         if (node->magic != JFFS2_MAGIC_BITMASK || !hdr_crc(node)) {
 842                                 offset += 4;
 843                                 ofs += 4;
 844                                 counter4++;
 845                                 continue;
 846                         }
 847                         /* if its a fragment add it */
 848                         if (node->nodetype == JFFS2_NODETYPE_INODE &&
 849                                     inode_crc((struct jffs2_raw_inode *) node)) {
 850                                 if (insert_inode(&pL->frag, (struct jffs2_raw_inode *) node,
 851                                                  offset) == NULL) {
 852                                         return 0;
 853                                 }
 854                         } else if (node->nodetype == JFFS2_NODETYPE_DIRENT &&
 855                                    dirent_crc((struct jffs2_raw_dirent *) node)  &&
 856                                    dirent_name_crc((struct jffs2_raw_dirent *) node)) {
 857                                 if (! (counterN%100))
 858                                         puts ("\b\b.  ");
 859                                 if (insert_dirent(&pL->dir, (struct jffs2_raw_dirent *) node,
 860                                                   offset) == NULL) {
 861                                         return 0;
 862                                 }
 863                                 counterN++;
 864                         } else if (node->nodetype == JFFS2_NODETYPE_CLEANMARKER) {
 865                                 if (node->totlen != sizeof(struct jffs2_unknown_node))
 866                                         printf("OOPS Cleanmarker has bad size "
 867                                                 "%d != %d\n", node->totlen,
 868                                                 sizeof(struct jffs2_unknown_node));
 869                         } else if (node->nodetype == JFFS2_NODETYPE_PADDING) {
 870                                 if (node->totlen < sizeof(struct jffs2_unknown_node))
 871                                         printf("OOPS Padding has bad size "
 872                                                 "%d < %d\n", node->totlen,
 873                                                 sizeof(struct jffs2_unknown_node));
 874                         } else {
 875                                 printf("Unknown node type: %x len %d "
 876                                         "offset 0x%x\n", node->nodetype,
 877                                         node->totlen, offset);
 878                         }
 879                         offset += ((node->totlen + 3) & ~3);
 880                         ofs += ((node->totlen + 3) & ~3);
 881                         counterF++;
 882                 }
 883         }
 884
 885         putstr("\b\b done.\r\n");               /* close off the dots */
 886
 887 #if 0
 888         putLabeledWord("dir entries = ", pL->dir.listCount);
 889         putLabeledWord("frag entries = ", pL->frag.listCount);
 890         putLabeledWord("+4 increments = ", counter4);
 891         putLabeledWord("+file_offset increments = ", counterF);
 892 #endif
 893
 894 #ifdef DEBUG_DIRENTS
 895         dump_dirents(pL);
 896 #endif
 897
 898 #ifdef DEBUG_FRAGMENTS
 899         dump_fragments(pL);
 900 #endif
 901
 902         /* give visual feedback that we are done scanning the flash */
 903         led_blink(0x0, 0x0, 0x1, 0x1);  /* off, forever, on 100ms, off 100ms */
 904         free(buf);
 905
 906         return 1;
 907 }
 908
 909
 910 static u32
 911 jffs2_1pass_fill_info(struct b_lists * pL, struct b_jffs2_info * piL)
 912 {
 913         struct b_node *b;
 914         struct jffs2_raw_inode ojNode;
 915         struct jffs2_raw_inode *jNode;
 916         int i;
 917
 918         for (i = 0; i < JFFS2_NUM_COMPR; i++) {
 919                 piL->compr_info[i].num_frags = 0;
 920                 piL->compr_info[i].compr_sum = 0;
 921                 piL->compr_info[i].decompr_sum = 0;
 922         }
 923 /*      FIXME
 924         b = pL->frag.listHead;
 925         while (b) {
 926                 jNode = (struct jffs2_raw_inode *) get_fl_mem(b->offset,
 927                         sizeof(ojNode), &ojNode);
 928                 if (jNode->compr < JFFS2_NUM_COMPR) {
 929                         piL->compr_info[jNode->compr].num_frags++;
 930                         piL->compr_info[jNode->compr].compr_sum += jNode->csize;
 931                         piL->compr_info[jNode->compr].decompr_sum += jNode->dsize;
 932                 }
 933                 b = b->next;
 934         }
 935 */
 936         return 0;
 937 }
 938
 939
 940 static struct b_lists *
 941 jffs2_get_list(struct part_info * part, const char *who)
 942 {
 943         if (jffs2_1pass_rescan_needed(part)) {
 944                 if (!jffs2_1pass_build_lists(part)) {
 945                         printf("%s: Failed to scan JFFSv2 file structure\n", who);
 946                         return NULL;
 947                 }
 948         }
 949         return (struct b_lists *)part->jffs2_priv;
 950 }
 951
 952
 953 /* Print directory / file contents */
 954 u32
 955 jffs2_1pass_ls(struct part_info * part, const char *fname)
 956 {
 957         struct b_lists *pl;
 958         long ret = 0;
 959         u32 inode;
 960
 961         if (! (pl = jffs2_get_list(part, "ls")))
 962                 return 0;
 963
 964         if (! (inode = jffs2_1pass_search_list_inodes(pl, fname, 1))) {
 965                 putstr("ls: Failed to scan jffs2 file structure\r\n");
 966                 return 0;
 967         }
 968
 969 #if 0
 970         putLabeledWord("found file at inode = ", inode);
 971         putLabeledWord("read_inode returns = ", ret);
 972 #endif
 973
 974         return ret;
 975 }
 976
 977
 978 /* Load a file from flash into memory. fname can be a full path */
 979 u32
 980 jffs2_1pass_load(char *dest, struct part_info * part, const char *fname)
 981 {
 982
 983         struct b_lists *pl;
 984         long ret = 0;
 985         u32 inode;
 986
 987         if (! (pl = jffs2_get_list(part, "load")))
 988                 return 0;
 989
 990         if (! (inode = jffs2_1pass_search_inode(pl, fname, 1))) {
 991                 putstr("load: Failed to find inode\r\n");
 992                 return 0;
 993         }
 994
 995         /* Resolve symlinks */
 996         if (! (inode = jffs2_1pass_resolve_inode(pl, inode))) {
 997                 putstr("load: Failed to resolve inode structure\r\n");
 998                 return 0;
 999         }
1000
1001         if ((ret = jffs2_1pass_read_inode(pl, inode, dest, NULL)) < 0) {
1002                 putstr("load: Failed to read inode\r\n");
1003                 return 0;
1004         }
1005
1006         DEBUGF ("load: loaded '%s' to 0x%lx (%ld bytes)\n", fname,
1007                                 (unsigned long) dest, ret);
1008         return ret;
1009 }
1010
1011 /* Return information about the fs on this partition */
1012 u32
1013 jffs2_1pass_info(struct part_info * part)
1014 {
1015         struct b_jffs2_info info;
1016         struct b_lists *pl;
1017         int i;
1018
1019         if (! (pl = jffs2_get_list(part, "info")))
1020                 return 0;
1021
1022         jffs2_1pass_fill_info(pl, &info);
1023         for (i = 0; i < JFFS2_NUM_COMPR; i++) {
1024                 printf ("Compression: %s\n"
1025                         "\tfrag count: %d\n"
1026                         "\tcompressed sum: %d\n"
1027                         "\tuncompressed sum: %d\n",
1028                         compr_names[i],
1029                         info.compr_info[i].num_frags,
1030                         info.compr_info[i].compr_sum,
1031                         info.compr_info[i].decompr_sum);
1032         }
1033         return 1;
1034 }
1035
1036 #endif