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