blob: d95f5513b97a5f089e260430879593951d29af02 [file] [log] [blame]
Wolfgang Denk932394a2005-08-17 12:55:25 +02001#include <common.h>
2
Jon Loeligerdd60d122007-07-09 17:56:50 -05003#if !defined(CFG_NAND_LEGACY) && defined(CONFIG_CMD_JFFS2)
Wolfgang Denk932394a2005-08-17 12:55:25 +02004
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
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +020015#define NODE_CHUNK 1024 /* size of memory allocation chunk in b_nodes */
Wolfgang Denk932394a2005-08-17 12:55:25 +020016
17/* Debugging switches */
18#undef DEBUG_DIRENTS /* print directory entry list after scan */
19#undef DEBUG_FRAGMENTS /* print fragment list after scan */
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +020020#undef DEBUG /* enable debugging messages */
Wolfgang Denk932394a2005-08-17 12:55:25 +020021
22#ifdef DEBUG
23# define DEBUGF(fmt,args...) printf(fmt ,##args)
24#else
25# define DEBUGF(fmt,args...)
26#endif
27
Wolfgang Denk932394a2005-08-17 12:55:25 +020028static nand_info_t *nand;
29
30/* Compression names */
31static 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 */
46static char spinner[] = { '|', '/', '-', '\\' };
47
48/* Memory management */
49struct mem_block {
50 unsigned index;
51 struct mem_block *next;
52 char nodes[0];
53};
54
55static void
56free_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
65static struct b_node *
66add_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
96static struct b_node *
97insert_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
138static struct b_node *
139insert_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
156static struct b_node *
157insert_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 */
180static 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 */
197static 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
238static u32
239jffs_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 */
262static long
263jffs2_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 */
369static u32
370jffs2_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) {
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +0200387 /* I'm pretty sure this isn't legal */
Wolfgang Denk932394a2005-08-17 12:55:25 +0200388 putstr(" ** ERROR ** ");
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +0200389/* putnstr(jDir->name, jDir->nsize); */
390/* putLabeledWord(" has dup version =", version); */
Wolfgang Denk932394a2005-08-17 12:55:25 +0200391 }
392 inode = jDir->ino;
393 version = jDir->version;
394 }
395 }
396 return inode;
397}
398
399char *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
429static 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
450static inline int
451dump_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 */
481static u32
482jffs2_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
505static u32
506jffs2_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
561static u32
562jffs2_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) {
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +0200576 if (jDir->version < version)
Wolfgang Denk932394a2005-08-17 12:55:25 +0200577 continue;
578
579 if (jDir->version == version && jDirFoundType) {
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +0200580 /* I'm pretty sure this isn't legal */
Wolfgang Denk932394a2005-08-17 12:55:25 +0200581 putstr(" ** ERROR ** ");
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +0200582/* putnstr(jDir->name, jDir->nsize); */
583/* putLabeledWord(" has dup version (resolve) = ", */
584/* version); */
Wolfgang Denk932394a2005-08-17 12:55:25 +0200585 }
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
616static u32
617jffs2_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
664unsigned char
665jffs2_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
Wolfgang Denk932394a2005-08-17 12:55:25 +0200688 /* 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
707static void
708dump_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
738static void
739dump_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);
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200761 putLabeledWord("\tbuild_list: offset = ", b->offset); /* FIXME: ? [RS] */
Wolfgang Denk932394a2005-08-17 12:55:25 +0200762 b = b->next;
763 put_fl_mem(jDir);
764 }
765}
766#endif
767
768static int
769jffs2_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
789static u32
790jffs2_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
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +0200802 struct mtdids *id = part->dev->id;
803 nand = nand_info + id->num;
Wolfgang Denk932394a2005-08-17 12:55:25 +0200804
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
910static u32
911jffs2_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
940static struct b_lists *
941jffs2_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 */
954u32
955jffs2_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 */
979u32
980jffs2_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
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +0200987 if (! (pl = jffs2_get_list(part, "load")))
Wolfgang Denk932394a2005-08-17 12:55:25 +0200988 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 */
1012u32
1013jffs2_1pass_info(struct part_info * part)
1014{
1015 struct b_jffs2_info info;
1016 struct b_lists *pl;
1017 int i;
1018
Wolfgang Denkac7eb8a2005-09-14 23:53:32 +02001019 if (! (pl = jffs2_get_list(part, "info")))
Wolfgang Denk932394a2005-08-17 12:55:25 +02001020 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
Jon Loeligerf40a7f32007-07-10 11:07:56 -05001036#endif